एंड्रॉइड: जब एडिटटेक्स्ट पर ध्यान केंद्रित किया जाता है, तो स्वचालित रूप से सॉफ्ट कीबोर्ड दिखाते हैं


341

मैं एक इनपुट बॉक्स का उपयोग करके दिखा रहा हूँ AlertDialogEditTextसंवाद अंदर स्वतः ही केंद्रित है जब मैं फोन AlertDialog.show()है, लेकिन मुलायम कीबोर्ड अपने आप नहीं दिखाया गया है।

डायलॉग दिखाए जाने पर मैं अपने आप सॉफ्ट कीबोर्ड कैसे दिखाऊं? (और कोई भौतिक / हार्डवेयर कीबोर्ड नहीं है)। वैश्विक खोज को लागू करने के लिए जब मैं खोज बटन दबाता हूं, तो उसके समान ही, नरम कीबोर्ड स्वचालित रूप से दिखाया जाता है।


1
नीचे टेड की टिप्पणी के अनुसार यह स्वचालित रूप से होना चाहिए । वह पहले जांच लें!
Cheezmeister

यह उत्तर सबसे सरल है और ठीक काम करता है: stackoverflow.com/a/8018630/89818
caw


1
मैं वर्षों में कई बार इस जवाब पर वापस आया हूं। यह हमेशा एक डायलॉग के अंदर होता है कि मुझे यह परेशानी हो रही है, कभी फ्रैगमेंट या एक्टिविटी नहीं।
tir38

जवाबों:


305

आप पर ध्यान देने के श्रोता बना सकते हैं EditTextपर AlertDialog, तो प्राप्त AlertDialogकी Window। वहां से आप कॉल करके सॉफ्ट कीबोर्ड शो बना सकते हैं setSoftInputMode

final AlertDialog dialog = ...;

editText.setOnFocusChangeListener(new View.OnFocusChangeListener() {
    @Override
    public void onFocusChange(View v, boolean hasFocus) {
        if (hasFocus) {
            dialog.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);
        }
    }
});

5
मैं इसे AlertDialog.Builder का उपयोग कैसे करूंगा? ... अंतिम AlertDialog.Builder अलर्ट = नया AlertDialog.Builder (Main.this);
स्टीफन

6
@ स्टीफन आप बिल्डर से डायलॉग प्राप्त कर सकते हैं final AlertDialog dialog = builder.create()और फिर showबिल्डर के बजाय डायलॉग पर।
tidbeck

30
मैं अपनी टिप्पणी अब प्राप्त करता हूं मुझे पता चला कि यदि आप ध्यान केंद्रित नहीं कर सकते हैं, तो अपने XML पर एक नज़र डालें! अगर आपको वहां पर <requestFocus> </ requestFocus> टैग दिखाई देता है - तो इसे हटा दें। ऐसा लगता है कि टैग EditText पर ध्यान केंद्रित करेगा, और फिर आपके श्रोता को निकाल नहीं दिया जाएगा क्योंकि EditText में पहले से ही फोकस है।
टेड

11
यदि डिवाइस में हार्डवेयर कीबोर्ड है तो आप यह कैसे नहीं करते हैं? ऐसा लगता है कि उन उपयोगकर्ताओं के लिए कष्टप्रद है।
mxcl

8
मैं वास्तव में यह नहीं समझता कि यह एसडीके में डिफ़ॉल्ट व्यवहार क्यों नहीं है। यदि पाठ इनपुट की आवश्यकता वाले दृश्य को ब्लिंकिंग कर्सर दिखाई देता है, तो कोई व्यक्ति कीबोर्ड से इनपुट टेक्स्ट क्यों नहीं देखना चाहेगा? यह एक UX मेरे लिए बहुत गलत लगता है
क्रिश्चियन गार्सिया

240

कीबोर्ड उपयोग दिखाने के लिए:

InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.SHOW_FORCED,0);

कीबोर्ड के उपयोग को छिपाने के लिए:

InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(view.getWindowToken(),0); 

3
यह तब विशेष रूप से अच्छी तरह से काम करता है जब आप विज़िबल और GONE के बीच अपने लेआउट में दृश्य की दृश्यता पर आधारित सॉफ्ट कीबोर्ड दिखाना / छिपाना चाहते हैं।
पैसिफिक जूल 5'12

38
मैं इसके बजाय SHOW_IMPLICIT ध्वज का उपयोग करने का सुझाव दूंगा, क्योंकि इसका मतलब है कि बदलती गतिविधि या एप्लिकेशन कीबोर्ड को उम्मीद के मुताबिक ऑटो-छिपा देगा।
drspaceboo

6
@drspaceboo SHOW_IMPLICIT का उपयोग करना मेरे लिए बिल्कुल भी काम नहीं करता है, मुझे SHOW_FORCED का उपयोग करना है, निश्चित नहीं कि क्यों ...
Yoann Hercouet

1
उपरोक्त कोड कब चलाया जाना चाहिए? मैंने अपने लेआउट को इसके अभिभावक के साथ जोड़ने के तुरंत बाद इसे करने की कोशिश की। यह काम नहीं किया। लेकिन अगर मैंने इसे लेआउट के बाद थोड़ी देर के लिए किया था, तो यह काम किया। तो क्या कोई कॉलबैक है जो मुझे बताएगा "यदि आप अभी कीबोर्ड दिखाने की कोशिश करते हैं, तो यह वास्तव में काम करेगा"?
विलियम जोकस

1
toggleSoftInput (InputMethodManager.SHOW_FORCED, 0) सॉफ्ट कीबोर्ड को टॉगल करता है। यदि आप यह सुनिश्चित करना चाहते हैं कि कीबोर्ड दिखाई देता है, तो आप इसके बजाय imm.showSoftInput (दृश्य, InputMethodManager.SHOW_IMPLICIT) का उपयोग कर सकते हैं, जहां दृश्य वह दृश्य है जिसे इनपुट मिलेगा।
PJ_Finnegan

111

आप संवाद बनाने के तुरंत बाद एक सॉफ्ट कीबोर्ड का अनुरोध कर सकते हैं (SDK - r20 पर परीक्षण)

// create dialog
final AlertDialog dialog = ...; 

// request keyboard   
dialog.getWindow().setSoftInputMode (WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);

किसी के लिए भी, यह तरीका सॉफ्ट कीबोर्ड को नहीं खोलता है जब हार्डवेयर कीबोर्ड जुड़ा होता है। मैंने अभी USB ऑन-द-गो केबल के साथ परीक्षण किया है। उत्तम!
13rac1

यह मेरे लिए कुछ नहीं करता है।
जॉनीटेक्स

मेरे पास कोई हार्डवेयर कीबोर्ड नहीं है। हो सकता है कॉन्फ़िगरेशन (?)
जॉनीटेक्स

25

मेरे पास एक ही समस्या थी और इसे निम्नलिखित कोड के साथ हल किया। मुझे यकीन नहीं है कि यह हार्डवेयर कीबोर्ड वाले फोन पर कैसे व्यवहार करेगा।

// TextEdit
final EditText textEdit = new EditText(this);

// Builder
AlertDialog.Builder alert = new AlertDialog.Builder(this);
alert.setTitle("Enter text");
alert.setView(textEdit);

alert.setPositiveButton("Ok", new DialogInterface.OnClickListener() {
    @Override
    public void onClick(DialogInterface dialog, int which) {
        String text = textEdit.getText().toString();
        finish();
    }
});

alert.setNegativeButton("Cancel", new DialogInterface.OnClickListener() {
    @Override
    public void onClick(DialogInterface dialog, int which) {
        finish();
    }
});

// Dialog
AlertDialog dialog = alert.create();
dialog.setOnShowListener(new OnShowListener() {

    @Override
    public void onShow(DialogInterface dialog) {
        InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
        imm.showSoftInput(textEdit, InputMethodManager.SHOW_IMPLICIT);
    }
});

dialog.show();

यह डायलॉग क्लास एपीआई स्तर 8. में है
टिंडेक

बाद में हटा दिया जाना चाहिए था: /
Jacek Kwiecie

@Xylian यह अभी भी प्रलेखन में है Dialog.setOnShowListener ()
tidbeck


18
<activity
    ...
    android:windowSoftInputMode="stateVisible" >
</activity>

या

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

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

मुझे एक 'getWindow ()' संदेश नहीं मिल रहा है। मैंने इसे डालने की कोशिश की है। और इसके पहले अन्य चीजें। मैं एडिटेक्स का उपयोग किए बिना कीबोर्ड प्राप्त करना चाहता हूं, बस स्क्रीन के एक निश्चित हिस्से में क्लिक करके।
Androidcoder

1
@Androidcoder, यह गतिविधि का एक हिस्सा है, इसलिए कुछ ऐसा जोड़ें ((Activity) context).getWindow()....
कूलमाइंड

15

अन्य उत्तरों से कोड के स्निपेट काम करते हैं, लेकिन यह हमेशा स्पष्ट नहीं होता है कि उन्हें कोड में कहां रखा जाए, खासकर यदि आप आधिकारिक संवाद ट्यूटोरियल का उपयोग कर रहे हैं AlertDialog.Builderऔर उसका अनुसरण कर रहे हैं क्योंकि यह उपयोग नहीं करता है या ।final AlertDialog ...alertDialog.show()

alertDialog.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);

के लिए बेहतर है

InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.SHOW_FORCED,0);

क्योंकि SOFT_INPUT_STATE_ALWAYS_VISIBLE कीबोर्ड को छिपा देगा यदि फोकस एडिटटेक्स्ट से हट जाता है, जहां SHOW_FORCED कीबोर्ड को तब तक प्रदर्शित करता रहेगा जब तक कि यह स्पष्ट रूप से खारिज नहीं किया जाता है, भले ही उपयोगकर्ता होमस्क्रीन पर लौटे या हाल के ऐप्स प्रदर्शित करता हो।

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

alert_dialog.xml:

<RelativeLayout
android:id="@+id/dialogRelativeLayout"
xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="wrap_content" >

    <!-- android:imeOptions="actionGo" sets the keyboard to have a "go" key instead of a "new line" key. -->
    <!-- android:inputType="textUri" disables spell check in the EditText and changes the "go" key from a check mark to an arrow. -->
    <EditText
        android:id="@+id/editText"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_marginTop="16dp"
        android:layout_marginLeft="4dp"
        android:layout_marginRight="4dp"
        android:layout_marginBottom="16dp"
        android:imeOptions="actionGo"
        android:inputType="textUri"/>

</RelativeLayout>

AlertDialog.java:

import android.app.Activity;
import android.app.Dialog;
import android.content.DialogInterface;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;
import android.os.Bundle;
import android.support.annotation.NonNull;
import android.support.v4.app.DialogFragment;
import android.support.v7.app.AlertDialog;
import android.support.v7.app.AppCompatDialogFragment;
import android.view.KeyEvent;
import android.view.LayoutInflater;
import android.view.View;
import android.view.WindowManager;
import android.widget.EditText;

public class CreateDialog extends AppCompatDialogFragment {
    // The public interface is used to send information back to the activity that called CreateDialog.
    public interface CreateDialogListener {
        void onCreateDialogCancel(DialogFragment dialog);    
        void onCreateDialogOK(DialogFragment dialog);
    }

    CreateDialogListener mListener;

    // Check to make sure that the activity that called CreateDialog implements both listeners.
    public void onAttach(Activity activity) {
        super.onAttach(activity);
        try {
            mListener = (CreateDialogListener) activity;
        } catch (ClassCastException e) {
            throw new ClassCastException(activity.toString() + " must implement CreateDialogListener.");
        }
    }

    // onCreateDialog requires @NonNull.
    @Override
    @NonNull
    public Dialog onCreateDialog(Bundle savedInstanceState) {
        AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(getActivity());
        LayoutInflater customDialogInflater = getActivity().getLayoutInflater();

        // Setup dialogBuilder.
        alertDialogBuilder.setTitle(R.string.title);
        alertDialogBuilder.setView(customDialogInflater.inflate(R.layout.alert_dialog, null));
        alertDialogBuilder.setNegativeButton(R.string.cancel, new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int which) {
                mListener.onCreateDialogCancel(CreateDialog.this);
            }
        });
        alertDialogBuilder.setPositiveButton(R.string.ok, new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int which) {
                mListener.onCreateDialogOK(CreateDialog.this);
            }
        });

        // Assign the resulting built dialog to an AlertDialog.
        final AlertDialog alertDialog = alertDialogBuilder.create();

        // Show the keyboard when the dialog is displayed on the screen.
        alertDialog.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);

        // We need to show alertDialog before we can setOnKeyListener below.
        alertDialog.show();

        EditText editText = (EditText) alertDialog.findViewById(R.id.editText);

        // Allow the "enter" key on the keyboard to execute "OK".
        editText.setOnKeyListener(new View.OnKeyListener() {
            public boolean onKey(View v, int keyCode, KeyEvent event) {
                // If the event is a key-down event on the "enter" button, select the PositiveButton "OK".
                if ((event.getAction() == KeyEvent.ACTION_DOWN) && (keyCode == KeyEvent.KEYCODE_ENTER)) {
                    // Trigger the create listener.
                    mListener.onCreateDialogOK(CreateDialog.this);

                    // Manually dismiss alertDialog.
                    alertDialog.dismiss();

                    // Consume the event.
                    return true;
                } else {
                    // If any other key was pressed, do not consume the event.
                    return false;
                }
            }
        });

        // onCreateDialog requires the return of an AlertDialog.
        return alertDialog;
    }
}

11

खैर, यह एक बहुत पुरानी पोस्ट है, अभी भी कुछ जोड़ना है।
ये 2 सरल तरीके हैं जो मुझे कीबोर्ड को नियंत्रण में रखने में मदद करते हैं और वे एकदम सही काम करते हैं:

कीबोर्ड दिखाएं

public void showKeyboard() {
    InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
    View v = getCurrentFocus();
    if (v != null)
        imm.showSoftInput(v, 0);
}

कीबोर्ड छुपाएं

public void hideKeyboard() {
    InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
    View v = getCurrentFocus();
    if (v != null)
        imm.hideSoftInputFromWindow(v.getWindowToken(), 0);
}

क्या है getCurrentFocus()?
कूलमाइंड

मैं देखता हूं, यह एक विधि है Activity
कूलमाइंड

10

मुझे yuku के समाधान के लिए कुछ अतिरिक्त जानकारी इंगित करने दें, क्योंकि मुझे यह काम करना कठिन लगा! मुझे अपने AlertDialog.Builder से AlertDialog ऑब्जेक्ट कैसे मिलता है? खैर, यह मेरे alert.show()निष्पादन का परिणाम है :

final AlertDialog.Builder alert = new AlertDialog.Builder(getActivity());
final EditText input = new EditText(getActivity());
alert.setView(input);

// do what you need, like setting positive and negative buttons...

final AlertDialog dialog = alert.show();

input.setOnFocusChangeListener(new OnFocusChangeListener() {
   @Override
   public void onFocusChange(View v, boolean hasFocus) {
      if(hasFocus) {
         dialog.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);
      }
   }
});

7

इस चर्चा पर एक नज़र डालें जो IME को मैन्युअल रूप से छिपाने और दिखाने के लिए संभालती है। हालाँकि, मेरी भावना यह है कि यदि कोई फ़ोकस EditTextIME को ऊपर नहीं ला रहा है तो यह है क्योंकि आप AlertDialog.show()अपने OnCreate()या किसी अन्य तरीके से कॉल कर रहे हैं जिसे स्क्रीन प्रस्तुत करने से पहले ही खाली कर दिया जाता है। करने के लिए इसे ले जा रहा है OnPostResume()कि इस मामले में मेरा मानना है कि इसे ठीक करना चाहिए।


6

हाँ आप इसके साथ कर सकते हैं setOnFocusChangeListenerयह आपकी मदद करेगा।

editText.setOnFocusChangeListener(new View.OnFocusChangeListener() {
    @Override
    public void onFocusChange(View v, boolean hasFocus) {
        if (hasFocus) {
            dialog.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);
        }
    }
});

4

मुझे पता है कि यह सवाल पुराना है क्योंकि मुझे लगता है कि एक एक्सटेंशन फ़ंक्शन का उपयोग करना एक संपादित पाठ के लिए कीबोर्ड दिखाने का एक प्रारंभिक तरीका है

यहाँ एक विधि है जिसका उपयोग मैं एक संपादन के लिए कीबोर्ड दिखाने के लिए करता हूँ।

कोटलिन कोड: बस कॉल करने की आवश्यकता हैedittext.showKeyboard()

fun EditText.showKeyboard() {
  post {
    requestFocus()
    val imm = context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
    imm.showSoftInput(this, InputMethodManager.SHOW_IMPLICIT)
  }
}

जावा कोड:

public static void showKeyboard(EditText editText) {
    editText.post(new Runnable() {
      @Override
      public void run() {
        editText.requestFocus();
        InputMethodManager imm = (InputMethodManager) editText.getContext()
            .getSystemService(Context.INPUT_METHOD_SERVICE);
        imm.showSoftInput(editText, InputMethodManager.SHOW_IMPLICIT);
      }
    });
  }

3

अगर किसी को मिल रहा है:

गैर-स्थैतिक विधि getSystemService (स्ट्रिंग) प्रकार गतिविधि से एक स्थिर संदर्भ नहीं बना सकता

संदर्भ जोड़ने का प्रयास करेंGetSystemService कॉल करने के लिए करें।

इसलिए

InputMethodManager imm = 
(InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.SHOW_FORCED,0);

1

मूल प्रश्न डायलॉग्स और मेरे EditText की नियमित दृष्टि पर है। किसी भी तरह, मुझे संदेह है कि यह आप में से अधिकांश के लिए भी काम करना चाहिए। तो यहाँ मेरे लिए क्या काम करता है (ऊपर सुझाई गई उच्चतम रेटेड पद्धति ने मेरे लिए कुछ नहीं किया)। यहाँ एक कस्टम EditView है जो ऐसा करता है (उपवर्ग आवश्यक नहीं है, लेकिन मुझे अपने उद्देश्यों के लिए यह सुविधाजनक लगा क्योंकि मैं चाहता था कि जब दृश्य दिखाई दे तो मैं भी फोकस को पकड़ सकूँ)।

यह वास्तव में काफी हद तक tidbecks जवाब के रूप में ही है। मुझे वास्तव में उसका जवाब बिल्कुल भी नहीं सूझा क्योंकि उसमें वोट शून्य थे। तब मैं सिर्फ उनकी पोस्ट के बारे में टिप्पणी करने वाला था, लेकिन यह बहुत लंबा होगा, इसलिए मैंने इस पोस्ट को वैसे भी करना समाप्त कर दिया। tidbeck बताते हैं कि वह अनिश्चित है कि यह कीबोर्ड वाले उपकरणों के साथ कैसे काम करता है। मैं यह पुष्टि कर सकता हूं कि व्यवहार दोनों ही मामलों में बिल्कुल एक जैसा प्रतीत होता है। कि चित्र मोड पर ऐसा होने के नाते सॉफ्टवेयर कीबोर्ड पॉप अप हो जाता है और परिदृश्य पर ऐसा नहीं होता है। फिजिकल कीबोर्ड के स्लिप होने या न होने से मेरे फोन पर कोई फर्क नहीं पड़ता।

क्योंकि, मैंने व्यक्तिगत रूप से व्यवहार को थोड़ा अजीब पाया, जिसका मैंने उपयोग करने का विकल्प चुना InputMethodManager.SHOW_FORCED:। यह काम करता है जैसा मैं चाहता था कि यह काम करे। कीबोर्ड अभिविन्यास की परवाह किए बिना दिखाई देता है, हालांकि, कम से कम मेरे डिवाइस पर यह पॉप अप नहीं होता है अगर हार्डवेयर कीबोर्ड बाहर स्लाइड किया गया हो।

import android.app.Service;
import android.content.Context;
import android.util.AttributeSet;
import android.view.View;
import android.view.inputmethod.InputMethodManager;
import android.widget.EditText;

public class BringOutTheSoftInputOnFocusEditTextView extends EditText {

    protected InputMethodManager inputMethodManager;

    public BringOutTheSoftInputOnFocusEditTextView(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        init();
    }

    public BringOutTheSoftInputOnFocusEditTextView(Context context, AttributeSet attrs) {
        super(context, attrs);
        init();
    }

    public BringOutTheSoftInputOnFocusEditTextView(Context context) {
        super(context);
        init();
    }

    private void init() {
        this.inputMethodManager = (InputMethodManager)getContext().getSystemService(Service.INPUT_METHOD_SERVICE);
        this.setOnFocusChangeListener(new View.OnFocusChangeListener() {
            @Override
            public void onFocusChange(View v, boolean hasFocus) {
                if (hasFocus) {
                    BringOutTheSoftInputOnFocusEditTextView.this.inputMethodManager.showSoftInput(BringOutTheSoftInputOnFocusEditTextView.this, InputMethodManager.SHOW_FORCED);
                }
            }
        });
    }

    @Override
    protected void onVisibilityChanged(View changedView, int visibility) {
        super.onVisibilityChanged(changedView, visibility);
        if (visibility == View.VISIBLE) {
            BringOutTheSoftInputOnFocusEditTextView.this.requestFocus();
        }
    }

}

1

समस्या यह प्रतीत होती है कि चूंकि आप जिस जगह पर पाठ दर्ज करते हैं वह शुरू में छिपा हुआ है (या नेस्टेड या कुछ और), AlertDialog स्वचालित रूप से ध्वज सेट कर रहा है WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IMयाWindowManager.LayoutParams.FLAG_NOT_FOCUSABLE ताकि चीजें दिखाने के लिए एक नरम इनपुट को ट्रिगर न करें।

इसे ठीक करने का तरीका निम्नलिखित जोड़ने के लिए है:

(...)
// Create the dialog and show it
Dialog dialog = builder.create()
dialog.show();

// After show (this is important specially if you have a list, a pager or other view that uses a adapter), clear the flags and set the soft input mode
dialog.getWindow().clearFlags(WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE|WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM);
dialog.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);

1

प्रयास करें और उपयोग करें:

editText.requestFocus();
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.SHOW_FORCED, InputMethodManager.HIDE_IMPLICIT_ONLY);

1

कीबोर्ड दिखाने के लिए, मेरे लिए, मुझे निम्नलिखित काम करना था

Android TextField: प्रोग्राम को फोकस + सॉफ्ट इनपुट सेट करें

अनिवार्य रूप से समाधान निम्नलिखित है

@Override
public void onResume() {
    super.onResume();
    //passwordInput.requestFocus(); <-- that doesn't work
    passwordInput.postDelayed(new ShowKeyboard(), 325); //250 sometimes doesn't run if returning from LockScreen
}

कहाँ ShowKeyboardहै

private class ShowKeyboard implements Runnable {
    @Override
    public void run() {
        passwordInput.setFocusableInTouchMode(true);
        //passwordInput.requestFocusFromTouch(); //this gives touch event to launcher in background -_-
        passwordInput.requestFocus();
        getActivity().getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);
        ((InputMethodManager) getActivity().getSystemService(Context.INPUT_METHOD_SERVICE)).showSoftInput(passwordInput, 0);
    }
}

एक सफल इनपुट के बाद, मैं यह भी सुनिश्चित करता हूं कि मैं कीबोर्ड छिपाऊं

getActivity().getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_HIDDEN);
((InputMethodManager) getActivity().getSystemService(Context.INPUT_METHOD_SERVICE))
                    .hideSoftInputFromWindow(getView().getWindowToken(), 0);

1

इन तरीकों को अपने Util क्लास में रखें और कहीं भी इस्तेमाल करें।

Kotlin

fun hideKeyboard(activity: Activity) {
    val view = activity.currentFocus
    val methodManager = activity.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
    assert(view != null)
    methodManager.hideSoftInputFromWindow(view!!.windowToken, InputMethodManager.HIDE_NOT_ALWAYS)
}

private fun showKeyboard(activity: Activity) {
    val view = activity.currentFocus
    val methodManager = activity.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
    assert(view != null)
    methodManager.showSoftInput(view, InputMethodManager.SHOW_IMPLICIT)
}

जावा

public static void hideKeyboard(Activity activity) {
    View view = activity.getCurrentFocus();
    InputMethodManager methodManager = (InputMethodManager) activity.getSystemService(Context.INPUT_METHOD_SERVICE);
    assert methodManager != null && view != null;
    methodManager.hideSoftInputFromWindow(view.getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);
}

private static void showKeyboard(Activity activity) {
    View view = activity.getCurrentFocus();
    InputMethodManager methodManager = (InputMethodManager) activity.getSystemService(Context.INPUT_METHOD_SERVICE);
    assert methodManager != null && view != null;
    methodManager.showSoftInput(view, InputMethodManager.SHOW_IMPLICIT);
}

1

मैं अच्छा kotlin-esqe विस्तार कार्यों बनाया किसी को भी रुचि है बना दिया

fun Activity.hideKeyBoard() {
    val view = this.currentFocus
    val methodManager = this.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
    assert(view != null)
    methodManager.hideSoftInputFromWindow(view!!.windowToken, InputMethodManager.HIDE_NOT_ALWAYS)
}

fun Activity.showKeyboard() {
    val view = this.currentFocus
    val methodManager = this.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
    assert(view != null)
    methodManager.showSoftInput(view, InputMethodManager.SHOW_IMPLICIT)
}

0

यह आपके लिए अच्छा नमूना है:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical" >

    <ScrollView
        android:id="@+id/scrollID"
        android:layout_width="fill_parent"
        android:layout_height="0dip"
        android:layout_weight="1" >

        <LinearLayout
            android:id="@+id/test"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:orientation="vertical" >
        </LinearLayout>
    </ScrollView>

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:baselineAligned="true"
        android:orientation="horizontal"
        android:paddingBottom="5dp"
        android:paddingLeft="5dp"
        android:paddingRight="5dp"
        android:weightSum="1" >

        <EditText
            android:id="@+id/txtInpuConversation"
            android:layout_width="0dip"
            android:layout_height="wrap_content"
            android:layout_weight="0.5"
            android:hint="@string/edt_Conversation" >

            <requestFocus />
        </EditText>

        <Button
            android:id="@+id/btnSend"
            android:layout_width="0dip"
            android:layout_height="wrap_content"
            android:layout_weight="0.5"
            android:text="@string/btn_Conversation" />
    </LinearLayout>

</LinearLayout>

0

यह उत्तर क्यों - क्योंकि उपरोक्त समाधान आपके कीबोर्ड को दिखाएगा लेकिन यदि आप कहीं और क्लिक करते हैं तो यह गायब नहीं होगा EditText। तो आपको EditTextफ़ोकस खोने पर कीबर्ड को गायब करने के लिए कुछ करने की ज़रूरत है ।

आप निम्न चरणों को करके इसे प्राप्त कर सकते हैं:

  1. निम्नलिखित विशेषताओं को जोड़कर अभिभावक दृश्य (आपकी गतिविधि का सामग्री दृश्य) क्लिक करने योग्य और ध्यान देने योग्य बनाएं

        android:clickable="true" 
        android:focusableInTouchMode="true" 
  2. एक HideKeyboard () विधि को लागू करें

        public void hideKeyboard(View view) {
            InputMethodManager inputMethodManager =(InputMethodManager)getSystemService(Activity.INPUT_METHOD_SERVICE);
            inputMethodManager.hideSoftInputFromWindow(view.getWindowToken(),InputMethodManager.HIDE_IMPLICIT_ONLY );
        }
  3. अंत में, अपने एडिटेक्स के onFocusChangeListener को सेट करें।

        edittext.setOnFocusChangeListener(new View.OnFocusChangeListener() {
            @Override
            public void onFocusChange(View v, boolean hasFocus) {
                if (!hasFocus) {
                    hideKeyboard(v);
                }
            }
        });

0

यह थोड़ा मुश्किल है। मैंने इस तरह से किया और यह काम किया।

1. सबसे पहले विंडो से सॉफ्ट इनपुट को छुपाने के लिए कॉल करें। यह सॉफ्ट इनपुट को छिपा देगा यदि सॉफ्ट कीबोर्ड दिखाई दे या ऐसा न हो तो कुछ भी न करें।

2. अपने संवाद को

3. जब बस नरम इनपुट टॉगल करने के लिए कहते हैं।

कोड:

InputMethodManager inputManager = (InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE); 
//hiding soft input
inputManager.hideSoftInputFromWindow(findViewById(android.R.id.content).getWind‌​owToken(), 0);
//show dialog
yourDialog.show();
//toggle soft input
inputManager.toggleSoftInput(InputMethodManager.SHOW_FORCED,InputMethodManager.SHOW_IMPLICIT);

0

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

SomeUtils.java

public static void showKeyboard(Activity activity, boolean show) {
    InputMethodManager inputMethodManager = (InputMethodManager) activity.getSystemService(Context.INPUT_METHOD_SERVICE);

    if(show)
        inputMethodManager.toggleSoftInput(InputMethodManager.SHOW_FORCED,0);
    else
        inputMethodManager.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY,0);
}

0

कोशिश की कई लेकिन यह मेरे लिए काम किया है (kotlin):

        val dialog = builder.create()
        dialog.setOnShowListener {
            nameEditText.requestFocus()
            val s = ContextCompat.getSystemService(requireContext(), InputMethodManager::class.java)
            s?.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0)
        }

        dialog.setOnDismissListener {
            val s = ContextCompat.getSystemService(requireContext(), InputMethodManager::class.java)
            s?.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0)
        }

        dialog.show()

0

Https://stackoverflow.com/a/39144104/2914140 को देखते हुए मैंने थोड़ा सरल किया:

// In onCreateView():
view.edit_text.run {
    requestFocus()
    post { showKeyboard(this) }
}

fun showKeyboard(view: View) {
    val imm = view.context.getSystemService(
        Context.INPUT_METHOD_SERVICE) as InputMethodManager?
    imm?.showSoftInput(view, InputMethodManager.SHOW_IMPLICIT)
}

यह https://stackoverflow.com/a/11155404/2914140 से बेहतर है :

InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);

क्योंकि जब आप होम बटन दबाते हैं और होम स्क्रीन पर जाते हैं, तो कीबोर्ड खुला रहेगा।


-1
getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);

जब मैं गतिविधि में आता हूं, तो मैं स्वचालित रूप से कीबोर्ड दिखाने के लिए इसे ऑनक्रीट () में कहता हूं।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.