event - checkboxgroup android example

Android EditText onClickListener

Question

Quiero un EditText que crea un DatePicker cuando se presiona. Así que escribo el siguiente código:

    mEditInit = (EditText) findViewById(R.id.date_init);
    mEditInit.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            showDialog(DATEINIT_DIALOG);
        }

    });

Pero cuando presiono EditarTexto, la acción es la típica: un cursor esperando a escribir texto en su lugar muestra el Diálogo que quiero.

¿Alguna idea?

Gracias

Answer 1

Aquí está la solución que implementé

mPickDate.setOnKeyListener(new View.OnKeyListener() {

    @Override
    public boolean onKey(View v, int keyCode, KeyEvent event) {
        showDialog(DATE_DIALOG_ID);
        return false;
    }
});

O

mPickDate.setOnFocusChangeListener(new View.OnFocusChangeListener() {

    @Override
    public void onFocusChange(View v, boolean hasFocus) {
        showDialog(DATE_DIALOG_ID);

    }
});

Vea las diferencias usted mismo. El problema es desde (como dijo RickNotFred) TextView para mostrar la fecha y editar a través del DatePicker. TextEdit no se usa para su propósito principal. Si desea que DatePicker vuelva a aparecer, debe ingresar delete (1st case) o de focus (2nd case).

Rayo

Answer 2

En mi humilde opinión, no estoy de acuerdo con la declaración de RickNotFred:

Hacer estallar un diálogo cuando EditText obtiene un foco parece una interfaz no estándar.

Mostrar un cuadro de diálogo para editar la fecha cuando el uso presiona el Editar texto es muy similar al predeterminado, que es mostrar un teclado o un teclado numérico. El hecho de que la fecha se muestre con EditText indica al usuario que la fecha puede cambiarse. Al mostrar la fecha como una vista de texto no editable se le indica al usuario que la fecha no se puede cambiar.

Answer 3

El teclado parece aparecer cuando EditText gana el foco. Para evitar esto, establezca enfocable en falso:

<EditText
    ...
    android:focusable="false"
    ... />

Este comportamiento puede variar según los gustos del sistema operativo Android de los fabricantes, pero en los dispositivos que he probado, he encontrado que es suficiente. Si el teclado sigue apareciendo, el uso de pistas en lugar de texto parece ayudar también:

myEditText.setText("My text");    // instead of this...
myEditText.setHint("My text");    // try this

Una vez que haya hecho esto, su escucha en clic debe funcionar como lo desee:

myEditText.setOnClickListener(new OnClickListener() {...});

Answer 4

Como lo sugirió Dillon Kearns, la configuración enfocable a falso funciona bien. Pero si su objetivo es cancelar el teclado cuando se hace clic en EditText, es posible que desee usar:

mEditText.setInputType(0);

Answer 5

Lo siguiente funciona perfectamente para mí.

Primero configure la entrada del widget selector de fecha en ''ninguno'' para evitar que aparezca el teclado virtual:

<EditText android:inputType="none" ... ></EditText>

A continuación, agregue estos detectores de eventos para mostrar el diálogo que contiene el selector de fecha:

// Date picker
EditText dateEdit = (EditText) findViewById(R.id.date);
dateOfBirthEdit.setOnTouchListener(new OnTouchListener() {
    @Override
    public boolean onTouch(View v, MotionEvent event) {
        if (event.getAction() == MotionEvent.ACTION_UP) {
            showDialog(DIALOG_DATE_PICKER);
        }
        return false;
    }
});

dateEdit.setOnFocusChangeListener(new OnFocusChangeListener() {

    @Override
    public void onFocusChange(View v, boolean hasFocus) {
        if (hasFocus) {
            showDialog(DIALOG_DATE_PICKER);
        } else {
            dismissDialog(DIALOG_DATE_PICKER);
        }
    }
});

Una última cosa. Para asegurarse de que los días, meses o años tipeados se copian correctamente del selector de fechas, llame a datePicker.clearFocus() antes de recuperar los valores, por ejemplo, a través de getMonth() .

Answer 6

Yo tuve el mísmo problema. El código está bien, pero asegúrese de cambiar el valor enfocable de EditText a falso.

<EditText
android:id="@+id/date"
android:focusable="false"/>

¡Espero que esto ayude a cualquiera que haya tenido un problema similar!

Answer 7

Esto es lo que funcionó para mí

Establecer editable en falso

<EditText android:id="@+id/dob"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:hint="Date of Birth"
android:inputType="none"
android:editable="false"

/>

A continuación, agregue un detector de eventos para OnFocusChange

private  View.OnFocusChangeListener onFocusChangeDOB= new View.OnFocusChangeListener() {

@Override
 public void onFocusChange(View v, boolean hasFocus) {
   if (hasFocus){
     showDialog(DATE_DIALOG_ID);
   }
 }
};

Answer 8

Normalmente, quieres la máxima compatibilidad con el comportamiento normal de EditText .

Por lo tanto, no debe usar android:focusable="false" ya que, sí, la vista ya no se podrá enfocar y se verá mal. El fondo dibujable ya no mostrará su estado "presionado", por ejemplo.

Lo que debes hacer es lo siguiente:

myEditText.setInputType(InputType.TYPE_NULL);
myEditText.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
        // showMyDialog();
    }
});
myEditText.setOnFocusChangeListener(new View.OnFocusChangeListener() {
    @Override
    public void onFocusChange(View v, boolean hasFocus) {
        if (hasFocus) {
            // showMyDialog();
        }
    }
});

Al establecer el tipo de entrada en TYPE_NULL , TYPE_NULL que TYPE_NULL el teclado del software.

Al configurar OnClickListener y OnFocusChangeListener , se asegura de que su cuadro de diálogo siempre se abra cuando el usuario hace clic en el campo EditText , tanto cuando se enfoca (primer clic) como en los clics posteriores.

Simplemente configurar android:inputType="none" o setInputType(InputType.TYPE_NULL) no siempre es suficiente. Para algunos dispositivos, también debe configurar android:editable="false" en XML, aunque está en desuso. Si ya no funciona, será ignorado (como todos los atributos XML que no son compatibles).

Answer 9

Buen tema Bien, lo he hecho. En archivo XML:

<EditText
    ...
    android:editable="false"
    android:inputType="none" />

En código Java:

txtDay.setOnClickListener(onOnClickEvent);
txtDay.setOnFocusChangeListener(onFocusChangeEvent);

private View.OnClickListener onOnClickEvent = new View.OnClickListener() {
    @Override
    public void onClick(View view) {
        dpDialog.show();
    }
};
private View.OnFocusChangeListener onFocusChangeEvent = new View.OnFocusChangeListener() {
    @Override
    public void onFocusChange(View v, boolean hasFocus) {
        if (hasFocus)
            dpDialog.show();
    }
};

Answer 10

¿Por qué nadie mencionó setOnTouchListener ? El uso de setOnTouchListener es fácil y correcto, y solo devuelve verdadero si el oyente ha consumido el evento, de lo contrario es falso.

Answer 11

Esto funciona para mí:

mEditInit = (EditText) findViewById(R.id.date_init);
mEditInit.setKeyListener(null);
mEditInit.setOnFocusChangeListener(new View.OnFocusChangeListener() {
        @Override
        public void onFocusChange(View v, boolean hasFocus) {
            if(hasFocus)
            {
                mEditInit.callOnClick();
            }
        }
    });
mEditInit.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
        showDialog(DATEINIT_DIALOG);
    }

});

Answer 12

EditText predeterminado de EditText : al hacer clic primero se enfoca y al segundo clic se maneja en onClickListener por lo que debe deshabilitar el enfoque. Luego, con el primer clic, se encargará onClickListener .

Para hacer eso, necesitas agregar este android:focusableInTouchMode="false" atributo a tu EditText . ¡Eso es!

Algo como esto:

    <EditText
        android:id="@+id/editText"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:focusableInTouchMode="false"
        android:inputType="text" />

Answer 13

Actualización del autor: la respuesta a continuación, aunque aceptada en ese momento (en los días de Eclair), es en gran parte irrelevante hoy. Los estándares de UX han evolucionado dramáticamente desde que fue escrito. Manteniendo la integridad y porque no puede eliminar una respuesta aceptada.

Hacer estallar un diálogo cuando EditText obtiene un foco parece una interfaz no estándar. Tenga en cuenta que la función normal de EditText se elude por completo, ya que ni siquiera podría hacer cambios en la fecha que eligió, porque cada vez que lo enfoca, aparece este cuadro de diálogo.

Ya que lo está usando como una Vista de texto, ¿por qué no simplemente usar un TextView real junto con un botón? Cuando se hace clic en el botón, abre el DatePicker y llama a TextView.setText () con la fecha formateada de la manera que quieras. Puede usar onClickListener para el botón y se comportará como espera. Creo que esto hará que la función sea más clara para los usuarios.