Le clavier tactile Android avec showSoftInput ne fonctionne pas?
J'ai créé une application triviale pour tester les fonctionnalités suivantes. Lorsque mon activité est lancée, elle doit être lancée avec le clavier logiciel ouvert.
Mon code ne fonctionne pas?!
J'ai essayé divers paramètres d '"état" dans le manifeste et différents indicateurs dans le code de InputMethodManager (imm).
J'ai inclus le paramètre dans le fichier AndroidManifest.xml et explicitement appelé dans l'activité onCreate.
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:Android="http://schemas.Android.com/apk/res/Android"
package="com.mycompany.Android.studyIme"
Android:versionCode="1"
Android:versionName="1.0">
<uses-sdk Android:minSdkVersion="7" />
<application Android:icon="@drawable/icon" Android:label="@string/app_name">
<activity Android:name=".StudyImeActivity"
Android:label="@string/app_name"
Android:windowSoftInputMode="stateAlwaysVisible">
<intent-filter>
<action Android:name="Android.intent.action.MAIN" />
<category Android:name="Android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
</manifest>
... la mise en page principale (main.xml) ...
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:Android="http://schemas.Android.com/apk/res/Android"
Android:orientation="vertical"
Android:layout_width="fill_parent"
Android:layout_height="fill_parent"
>
<TextView
Android:layout_width="fill_parent"
Android:layout_height="wrap_content"
Android:text="@string/hello"
/>
<EditText
Android:id="@+id/edit_sample_text"
Android:layout_width="fill_parent"
Android:layout_height="wrap_content"
Android:hint="@string/hello"
Android:inputType="textShortMessage"
/>
</LinearLayout>
... et le code ...
public class StudyImeActivity extends Activity {
private EditText mEditTextStudy;
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
mEditTextStudy = (EditText) findViewById(R.id.edit_study);
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.showSoftInput(mEditTextStudy, InputMethodManager.SHOW_FORCED);
}
}
C'est tellement subtil que c'est criminel. Cela fonctionne sur les téléphones qui ET NON ont un clavier dur coulissant. Les téléphones dotés d'un clavier ne s'ouvriront pas automatiquement avec cet appel. Mon LG et mon ancien Nexus One n’ont pas de clavier. Par conséquent, le clavier logiciel s’ouvre lorsque l’activité démarre (c’est ce que je veux), mais les téléphones MyTouch et HTC G2 dotés de claviers coulissants n'ouvrez pas le clavier logiciel tant que je n'ai pas touché le champ d'édition avec le clavier physique fermé.
Lorsque l'activité démarre, il semble que le clavier soit initialement affiché mais caché par autre chose, car les opérations suivantes fonctionnent (il s'agit en réalité d'une solution de contournement):
Première méthode
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
editText.postDelayed(new Runnable()
{
@Override
public void run()
{
editText.requestFocus();
imm.showSoftInput(editText, 0);
}
}, 100);
Deuxième méthode
dans onCreate pour lancer l'activité créer
new Handler().postDelayed(new Runnable() {
@Override
public void run()
{
// InputMethodManager inputMethodManager=(InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE);
// inputMethodManager.toggleSoftInputFromWindow(EnterYourViewHere.getApplicationWindowToken(), InputMethodManager.SHOW_FORCED, 0);
if (inputMethodManager != null)
{
inputMethodManager.toggleSoftInput(InputMethodManager.SHOW_FORCED,0);
}
}
}, 200);
Troisième méthode AJOUTER le code donné à l’étiquette d’activité dans Manifest. Il affichera le clavier au lancement et définira le premier focus sur votre vue souhaitée.
Android:windowSoftInputMode="stateVisible"
Hé, j'espère que vous cherchez toujours la réponse, comme je l'ai trouvée lors du test de mon code. voici le code:
InputMethodManager imm = (InputMethodManager)_context.getSystemService(Context.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(0, 0);
Voici ma question à laquelle j'ai répondu: Android - Afficher le clavier virtuel à la demande
Cela a fonctionné avec moi sur un téléphone avec clavier dur:
editText1.requestFocus();
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.SHOW_FORCED,0);
Cette réponse est peut-être tardive, mais cela fonctionne parfaitement pour moi. Peut-être que ça aide quelqu'un :)
public void showSoftKeyboard(View view) {
if (view.requestFocus()) {
InputMethodManager imm = (InputMethodManager)
getSystemService(Context.INPUT_METHOD_SERVICE);
boolean isShowing = imm.showSoftInput(view, InputMethodManager.SHOW_IMPLICIT);
if (!isShowing)
getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_VISIBLE);
}
}
Dépend de vos besoins, vous pouvez utiliser d'autres drapeaux
InputMethodManager.SHOW_FORCED
WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);
La suite a fonctionné pour moi:
mEditTextStudy.requestFocus();
mEditTextStudy.post(
new Runnable() {
@Override
public void run() {
InputMethodManager imm =
(InputMethodManager)
getActivity()
.getSystemService(Context.INPUT_METHOD_SERVICE);
if (imm != null) {
imm.showSoftInput(mEditTextStudy, SHOW_FORCED);
}
}
});
Afficher Soft Keyboard est un gros problème. J'ai cherché beaucoup pour arriver à une conclusion finale. Merci à cette réponse qui a donné un certain nombre d'indices: https://stackoverflow.com/a/16882749/5903344
Problème:
Normalement, nous appelons showSoftInput dès que nous initialisons les vues. Dans Activités, il s’agit principalement de onCreate, dans Fragments onCreateView. Pour afficher le clavier, le module de gestion intégré doit avoir la fonction focsedView active. Ceci peut être vérifié en utilisant la méthode isActive (view) de IMM. Si nous appelons showSoftInput pendant la création des vues, il y a de fortes chances que la vue ne soit pas active pour IMM. C’est la raison pour laquelle un showSoftInput retardé de 50 à 100 ms est parfois utile. Cependant, cela ne garantit toujours pas qu'après 100 ms, la vue deviendra active. Donc, dans ma compréhension, ceci est encore un hack.
Solution:
J'utilise la classe suivante. Ceci continue à s'exécuter toutes les 100 ms jusqu'à ce que le clavier soit affiché avec succès. Il effectue diverses vérifications à chaque itération. Certaines vérifications peuvent arrêter le runnable, d'autres après 100 ms.
public class KeyboardRunnable extends Runnable
{
// ----------------------- Constants ----------------------- //
private static final String TAG = "KEYBOARD_RUNNABLE";
// Runnable Interval
private static final int INTERVAL_MS = 100;
// ----------------------- Classes ---------------------------//
// ----------------------- Interfaces ----------------------- //
// ----------------------- Globals ----------------------- //
private Activity parentActivity = null;
private View targetView = null;
// ----------------------- Constructor ----------------------- //
public KeyboardRunnable(Activity parentActivity, View targetView)
{
this.parentActivity = parentActivity;
this.targetView = targetView;
}
// ----------------------- Overrides ----------------------- //
@Override
public void run()
{
// Validate Params
if ((parentActivity == null) || (targetView == null))
{
Dbg.error(TAG, "Invalid Params");
return;
}
// Get Input Method Manager
InputMethodManager imm = (InputMethodManager) parentActivity.getSystemService(Context.INPUT_METHOD_SERVICE);
// Check view is focusable
if (!(targetView.isFocusable() && targetView.isFocusableInTouchMode()))
{
Dbg.error(TAG, "Non focusable view");
return;
}
// Try focusing
else if (!targetView.requestFocus())
{
Dbg.error(TAG, "Cannot focus on view");
Post();
}
// Check if Imm is active with this view
else if (!imm.isActive(targetView))
{
Dbg.error(TAG, "IMM is not active");
Post();
}
// Show Keyboard
else if (!imm.showSoftInput(targetView, InputMethodManager.SHOW_IMPLICIT))
{
Dbg.error(TAG, "Unable to show keyboard");
Post();
}
}
// ----------------------- Public APIs ----------------------- //
public static void Hide(Activity parentActivity)
{
if (parentActivity != null)
{
InputMethodManager imm = (InputMethodManager) parentActivity.getSystemService(Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(parentActivity.findViewById(Android.R.id.content).getWindowToken(), 0);
}
else
{
Dbg.error(TAG, "Invalid params to hide keyboard");
}
}
// ----------------------- Private APIs ----------------------- //
protected void Post()
{
// Post this aftr 100 ms
handler.postDelayed(this, INTERVAL_MS);
}
}
Pour l'utiliser, il suffit de créer une instance de cette classe. Transmettez-la à l’activité parente et à la cible qui aurait ensuite la saisie au clavier et le focus. Ensuite, publiez l'instance à l'aide d'un gestionnaire.
Mon code comportait la bascule mais pas postdelayed. J'avais essayé sans succès postDelayed pour showSoftInput et j'ai depuis essayé votre solution suggérée. J'étais sur le point de l'abandonner car c'était une solution potentielle qui échouait jusqu'à ce que je décide d'augmenter le délai. Cela fonctionne pour moi jusqu’à 200 ms, point auquel cela ne fonctionne pas, du moins pas sur les téléphones physiques. Donc, avant que les pauvres développeurs Android n’écartent leur réponse, essayez d’allonger le délai pour réussir votre solution. Il peut être avantageux d’ajouter un peu pour les anciens téléphones plus lents. Merci beaucoup, travaillait sur celui-ci pendant des heures.
Solution pour les développeurs Xamarin (_digit1 == EditText):
var focussed = _digit1.RequestFocus();
if (focussed)
{
Window.SetSoftInputMode(SoftInput.StateAlwaysVisible);
var imm = (InputMethodManager)GetSystemService(InputMethodService);
imm.ToggleSoftInput(ShowFlags.Forced, 0);
}
Cela fonctionne pour moi:
public void requestFocusAndShowSoftInput(View view){
view.requestFocus();
InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(INPUT_METHOD_SERVICE);
inputMethodManager.showSoftInput(view, InputMethodManager.SHOW_IMPLICIT);
}