¿Cómo crear nuestra propia interfaz de escucha en Android?

¿Podría alguien ayudarme a crear una interfaz de escucha definida por el usuario con algunos fragmentos de código?

Crea un nuevo archivo:

MyListener.java :

 public interface MyListener { // you can define any parameter as per your requirement public void callback(View view, String result); } 

En su actividad, implemente la interfaz:

MyActivity.java :

 public class MyActivity extends Activity implements MyListener { @override public void onCreate(){ MyButton m = new MyButton(this); } // method is invoked when MyButton is clicked @override public void callback(View view, String result) { // do your stuff here } } 

En su clase personalizada, invoque la interfaz cuando sea necesario:

MyButton.java :

 public class MyButton { MyListener ml; // constructor MyButton(MyListener ml) { //Setting the listener this.ml = ml; } public void MyLogicToIntimateOthers() { //Invoke the interface ml.callback(this, "success"); } } 

por favor, lea patrón de observador

interfaz de escucha

 public interface OnEventListener { void onEvent(EventResult er); // or void onEvent(); as per your need } 

entonces en tu clase di la clase de Event

 public class Event { private OnEventListener mOnEventListener; public void setOnEventListener(OnEventListener listener) { mOnEventListener = listener; } public void doEvent() { /* * code code code */ // and in the end if (mOnEventListener != null) mOnEventListener.onEvent(eventResult); // event result object :) } } 

en tu clase de controlador MyTestDriver

 public class MyTestDriver { public static void main(String[] args) { Event e = new Event(); e.setOnEventListener(new OnEventListener() { public void onEvent(EventResult er) { // do your work. } }); e.doEvent(); } } 

Creé un Escuchador AsyncTask genérico que obtiene el resultado de la clase separada AsycTask y se lo entrego a CallingActivity usando Callback Interface.

 new GenericAsyncTask(context,new AsyncTaskCompleteListener() { public void onTaskComplete(String response) { // do your work. } }).execute(); 

Interfaz

 interface AsyncTaskCompleteListener { public void onTaskComplete(T result); } 

GenericAsyncTask

 class GenericAsyncTask extends AsyncTask { private AsyncTaskCompleteListener callback; public A(Context context, AsyncTaskCompleteListener cb) { this.context = context; this.callback = cb; } protected void onPostExecute(String result) { finalResult = result; callback.onTaskComplete(result); } } 

Echa un vistazo a esta , esta pregunta para más detalles.

Crear interfaz de escucha

 public interface YourCustomListener { public void onCustomClick(View view); // pass view as argument or whatever you want. } 

Y crea el método setOnCustomClick en otra actividad (o fragmento), donde quieras aplicar tu oyente personalizado ……

  public void setCustomClickListener(YourCustomListener yourCustomListener) { this.yourCustomListener= yourCustomListener; } 

Llame a este método desde su Primera actividad y pase la interfaz del oyente …

Hay 4 pasos:

1.crear clase de interfaz (oyente)

2. usar la interfaz en la vista 1 (definir la variable)

3. Interfaz de los objectives para ver 2 (vista 1 utilizada en la vista 2)

4. interfaz de paso en la vista 1 para ver 2

Ejemplo:

Paso 1: necesitas crear la interfaz y definir la función

 public interface onAddTextViewCustomListener { void onAddText(String text); } 

Paso 2: usa esta interfaz a la vista

 public class CTextView extends TextView { onAddTextViewCustomListener onAddTextViewCustomListener; //listener custom public CTextView(Context context, onAddTextViewCustomListener onAddTextViewCustomListener) { super(context); this.onAddTextViewCustomListener = onAddTextViewCustomListener; init(context, null); } public CTextView(Context context, @Nullable AttributeSet attrs) { super(context, attrs); init(context, attrs); } public CTextView(Context context, @Nullable AttributeSet attrs, int defStyleAttr) { super(context, attrs, defStyleAttr); init(context, attrs); } @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP) public CTextView(Context context, @Nullable AttributeSet attrs, int defStyleAttr, int defStyleRes) { super(context, attrs, defStyleAttr, defStyleRes); init(context, attrs); } public void init(Context context, @Nullable AttributeSet attrs) { if (isInEditMode()) return; //call listener onAddTextViewCustomListener.onAddText("this TextView added"); } } 

Paso 3,4: implementa a la actividad

 public class MainActivity extends AppCompatActivity implements onAddTextViewCustomListener { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); //get main view from layout RelativeLayout mainView = (RelativeLayout)findViewById(R.id.mainView); //create new CTextView and set listener CTextView cTextView = new CTextView(getApplicationContext(), this); //add cTextView to mainView mainView.addView(cTextView); } @Override public void onAddText(String text) { Log.i("Message ", text); } } 

En Android, puede crear una interfaz como Listener, y su Activity lo implementa, pero no creo que sea una buena idea. si tenemos muchos componentes para escuchar los cambios de su estado, podemos crear un BaseListener implementa el Listener de interfaz, y usar el código de tipo para manejarlos. podemos vincular el método cuando creamos un archivo XML, por ejemplo:

  

y el código fuente:

  public void Btn4OnClick(View view) { String strTmp = "点击Button04"; tv.setText(strTmp); } 

pero no creo que sea una buena idea …

En el año de 2018, no hay necesidad de interfaces de oyentes. Tienes Android LiveData para encargarse de pasar el resultado deseado a los componentes de la interfaz de usuario.

Si tomo la respuesta de Rupesh y la ajusto para usar LiveData, me gustará:

 public class Event { public LiveData doEvent() { /* * code code code */ // and in the end LiveData result = new MutableLiveData<>(); result.setValue(eventResult); return result; } } 

y ahora en su clase de controlador MyTestDriver:

 public class MyTestDriver { public static void main(String[] args) { Event e = new Event(); e.doEvent().observe(this, new Observer() { @Override public void onChanged(final EventResult er) { // do your work. } }); } } 

Para obtener más información junto con muestras de código, puede leer mi publicación al respecto, así como los documentos oficiales:

Cuándo y por qué usar LiveData

Documentos oficiales

Método simple para hacer este enfoque. Primero implementa los OnClickListeners en su clase de Actividad.

Código:

 class MainActivity extends Activity implements OnClickListeners{ protected void OnCreate(Bundle bundle) { super.onCreate(bundle); setContentView(R.layout.activity_main.xml); Button b1=(Button)findViewById(R.id.sipsi); Button b2=(Button)findViewById(R.id.pipsi); b1.SetOnClickListener(this); b2.SetOnClickListener(this); } public void OnClick(View V) { int i=v.getId(); switch(i) { case R.id.sipsi: { //you can do anything from this button break; } case R.id.pipsi: { //you can do anything from this button break; } } }