Jak obsługiwać kliknięcia przycisków za pomocą XML onClick w obrębie fragmentów

Pre-Honeycomb (Android 3), każde działanie zostało zarejestrowane do obsługi kliknięć przycisków za pomocą onClickznacznika w pliku XML układu:

android:onClick="myClickMethod"

W ramach tej metody można użyć view.getId()instrukcji switch do wykonania logiki przycisku.

Wraz z wprowadzeniem plastra miodu dzielę te działania na fragmenty, które można ponownie wykorzystać w wielu różnych działaniach. Większość zachowań przycisków jest niezależna od działania i chciałbym, aby kod znajdował się w pliku Fragments bez używania starej (wcześniejszej niż 1.6) metody rejestracji OnClickListenerdla każdego przycisku.

final Button button = (Button) findViewById(R.id.button_id);
button.setOnClickListener(new View.OnClickListener() {
    public void onClick(View v) {
        // Perform action on click
    }
});

Problem polega na tym, że kiedy mój układ jest zawyżony, to nadal działanie hostingu otrzymuje kliknięcia przycisku, a nie poszczególne fragmenty. Czy istnieje dobre podejście do któregoś z nich

• Zarejestruj fragment, aby otrzymywać kliknięcia przycisku?
• Czy przekazać zdarzenia kliknięcia z działania do fragmentu, do którego należą?

Możesz po prostu to zrobić:

Czynność:

Fragment someFragment;    

//...onCreate etc instantiating your fragments

public void myClickMethod(View v) {
    someFragment.myClickMethod(v);
}

Fragment:

public void myClickMethod(View v) {
    switch(v.getId()) {
        // Just like you were doing
    }
}    

W odpowiedzi na @Ameen, która chciała mniej sprzężenia, więc Fragmenty mogą być ponownie użyte

Berło:

public interface XmlClickable {
    void myClickMethod(View v);
}

Czynność:

XmlClickable someFragment;    

//...onCreate, etc. instantiating your fragments casting to your interface.

public void myClickMethod(View v) {
    someFragment.myClickMethod(v);
}

Fragment:

public class SomeFragment implements XmlClickable {

//...onCreateView, etc.

@Override
public void myClickMethod(View v) {
    switch(v.getId()){
        // Just like you were doing
    }
}    

Wolę używać następującego rozwiązania do obsługi zdarzeń onClick. Działa to również w przypadku działania i fragmentów.

public class StartFragment extends Fragment implements OnClickListener{

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
            Bundle savedInstanceState) {

        View v = inflater.inflate(R.layout.fragment_start, container, false);

        Button b = (Button) v.findViewById(R.id.StartButton);
        b.setOnClickListener(this);
        return v;
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()) {
        case R.id.StartButton:

            ...

            break;
        }
    }
}

Myślę, że problem polega na tym, że widok wciąż jest działalnością, a nie fragmentem. Fragmenty nie mają własnego niezależnego widoku i są dołączone do widoku działań nadrzędnych. Właśnie dlatego wydarzenie kończy się Aktywnością, a nie fragmentem. To niefortunne, ale myślę, że będziesz potrzebować trochę kodu, aby to zadziałało.

To, co robiłem podczas konwersji, to po prostu dodanie detektora kliknięć, który wywołuje starą procedurę obsługi zdarzeń.

na przykład:

final Button loginButton = (Button) view.findViewById(R.id.loginButton);
loginButton.setOnClickListener(new OnClickListener() {
    @Override
    public void onClick(final View v) {
        onLoginClicked(v);
    }
});

Niedawno rozwiązałem ten problem bez konieczności dodawania metody do działania kontekstu lub konieczności implementowania OnClickListener. Nie jestem pewien, czy jest to „prawidłowe” rozwiązanie, ale działa.

Na podstawie: https://developer.android.com/tools/data-binding/guide.html#binding_events

Można to zrobić za pomocą powiązań danych: wystarczy dodać instancję fragmentu jako zmienną, a następnie można połączyć dowolną metodę za pomocą onClick.

<layout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    tools:context="com.example.testapp.fragments.CustomFragment">

    <data>
        <variable android:name="fragment" android:type="com.example.testapp.fragments.CustomFragment"/>
    </data>
    <LinearLayout
        android:orientation="vertical"
        android:layout_width="match_parent"
        android:layout_height="match_parent">

        <ImageButton
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:src="@drawable/ic_place_black_24dp"
            android:onClick="@{() -> fragment.buttonClicked()}"/>
    </LinearLayout>
</layout>

Fragment kodu łączącego byłby ...

public class CustomFragment extends Fragment {

    ...

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
                             Bundle savedInstanceState) {
        // Inflate the layout for this fragment
        View view = inflater.inflate(R.layout.fragment_person_profile, container, false);
        FragmentCustomBinding binding = DataBindingUtil.bind(view);
        binding.setFragment(this);
        return view;
    }

    ...

}

ButterKnife jest prawdopodobnie najlepszym rozwiązaniem problemu bałaganu. Wykorzystuje procesory adnotacji do generowania tak zwanego kodu „starej metody”.

Ale nadal można używać metody onClick z niestandardowym inflatorem.

Jak używać

@Override
public View onCreateView(LayoutInflater inflater, ViewGroup cnt, Bundle state) {
    inflater = FragmentInflatorFactory.inflatorFor(inflater, this);
    return inflater.inflate(R.layout.fragment_main, cnt, false);
}

Realizacja

public class FragmentInflatorFactory implements LayoutInflater.Factory {

    private static final int[] sWantedAttrs = { android.R.attr.onClick };

    private static final Method sOnCreateViewMethod;
    static {
        // We could duplicate its functionallity.. or just ignore its a protected method.
        try {
            Method method = LayoutInflater.class.getDeclaredMethod(
                    "onCreateView", String.class, AttributeSet.class);
            method.setAccessible(true);
            sOnCreateViewMethod = method;
        } catch (NoSuchMethodException e) {
            // Public API: Should not happen.
            throw new RuntimeException(e);
        }
    }

    private final LayoutInflater mInflator;
    private final Object mFragment;

    public FragmentInflatorFactory(LayoutInflater delegate, Object fragment) {
        if (delegate == null || fragment == null) {
            throw new NullPointerException();
        }
        mInflator = delegate;
        mFragment = fragment;
    }

    public static LayoutInflater inflatorFor(LayoutInflater original, Object fragment) {
        LayoutInflater inflator = original.cloneInContext(original.getContext());
        FragmentInflatorFactory factory = new FragmentInflatorFactory(inflator, fragment);
        inflator.setFactory(factory);
        return inflator;
    }

    @Override
    public View onCreateView(String name, Context context, AttributeSet attrs) {
        if ("fragment".equals(name)) {
            // Let the Activity ("private factory") handle it
            return null;
        }

        View view = null;

        if (name.indexOf('.') == -1) {
            try {
                view = (View) sOnCreateViewMethod.invoke(mInflator, name, attrs);
            } catch (IllegalAccessException e) {
                throw new AssertionError(e);
            } catch (InvocationTargetException e) {
                if (e.getCause() instanceof ClassNotFoundException) {
                    return null;
                }
                throw new RuntimeException(e);
            }
        } else {
            try {
                view = mInflator.createView(name, null, attrs);
            } catch (ClassNotFoundException e) {
                return null;
            }
        }

        TypedArray a = context.obtainStyledAttributes(attrs, sWantedAttrs);
        String methodName = a.getString(0);
        a.recycle();

        if (methodName != null) {
            view.setOnClickListener(new FragmentClickListener(mFragment, methodName));
        }
        return view;
    }

    private static class FragmentClickListener implements OnClickListener {

        private final Object mFragment;
        private final String mMethodName;
        private Method mMethod;

        public FragmentClickListener(Object fragment, String methodName) {
            mFragment = fragment;
            mMethodName = methodName;
        }

        @Override
        public void onClick(View v) {
            if (mMethod == null) {
                Class<?> clazz = mFragment.getClass();
                try {
                    mMethod = clazz.getMethod(mMethodName, View.class);
                } catch (NoSuchMethodException e) {
                    throw new IllegalStateException(
                            "Cannot find public method " + mMethodName + "(View) on "
                                    + clazz + " for onClick");
                }
            }

            try {
                mMethod.invoke(mFragment, v);
            } catch (InvocationTargetException e) {
                throw new RuntimeException(e);
            } catch (IllegalAccessException e) {
                throw new AssertionError(e);
            }
        }
    }
}

Wolałbym raczej obsługiwać kliknięcia w kodzie niż używać onClickatrybutu w XML podczas pracy z fragmentami.

Staje się to jeszcze łatwiejsze podczas migracji działań do fragmentów. Możesz po prostu wywołać moduł obsługi kliknięć (wcześniej ustawiony na android:onClickXML) bezpośrednio z każdego casebloku.

findViewById(R.id.button_login).setOnClickListener(clickListener);
...

OnClickListener clickListener = new OnClickListener() {
    @Override
    public void onClick(final View v) {
        switch(v.getId()) {
           case R.id.button_login:
              // Which is supposed to be called automatically in your
              // activity, which has now changed to a fragment.
              onLoginClick(v);
              break;

           case R.id.button_logout:
              ...
        }
    }
}

Jeśli chodzi o obsługę kliknięć we fragmentach, wydaje mi się to prostsze niż android:onClick.

To inny sposób ：

1. Utwórz BaseFragment w ten sposób:

public abstract class BaseFragment extends Fragment implements OnClickListener

2. Użyj

public class FragmentA extends BaseFragment 

zamiast

public class FragmentA extends Fragment

3.W swojej działalności:

public class MainActivity extends ActionBarActivity implements OnClickListener

i

BaseFragment fragment = new FragmentA;

public void onClick(View v){
    fragment.onClick(v);
}

Mam nadzieję, że to pomoże.

W moim przypadku mam 50 nieparzystych widoków obrazu, których potrzebowałem, aby podłączyć się do jednej metody onClick. Moim rozwiązaniem jest zapętlenie widoków wewnątrz fragmentu i ustawienie tego samego detektora onclick na każdym:

    final View.OnClickListener imageOnClickListener = new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            chosenImage = ((ImageButton)v).getDrawable();
        }
    };

    ViewGroup root = (ViewGroup) getView().findViewById(R.id.imagesParentView);
    int childViewCount = root.getChildCount();
    for (int i=0; i < childViewCount; i++){
        View image = root.getChildAt(i);
        if (image instanceof ImageButton) {
            ((ImageButton)image).setOnClickListener(imageOnClickListener);
        }
    }

Widzę odpowiedzi, że są jakoś stare. Ostatnio Google wprowadza DataBinding, które jest o wiele łatwiejsze w obsłudze przy kliknięciu lub przypisaniu pliku xml.

Oto dobry przykład, który możesz zobaczyć, jak sobie z tym poradzić:

<?xml version="1.0" encoding="utf-8"?>
<layout xmlns:android="http://schemas.android.com/apk/res/android">
   <data>
       <variable name="handlers" type="com.example.Handlers"/>
       <variable name="user" type="com.example.User"/>
   </data>
   <LinearLayout
       android:orientation="vertical"
       android:layout_width="match_parent"
       android:layout_height="match_parent">
       <TextView android:layout_width="wrap_content"
           android:layout_height="wrap_content"
           android:text="@{user.firstName}"
           android:onClick="@{user.isFriend ? handlers.onClickFriend : handlers.onClickEnemy}"/>
       <TextView android:layout_width="wrap_content"
           android:layout_height="wrap_content"
           android:text="@{user.lastName}"
           android:onClick="@{user.isFriend ? handlers.onClickFriend : handlers.onClickEnemy}"/>
   </LinearLayout>
</layout>

Jest też bardzo fajny samouczek na temat DataBinding, który można znaleźć tutaj .

Odwołanie można zdefiniować jako atrybut układu XML. Artykuł Niestandardowe atrybuty XML dla niestandardowych widżetów na Androida pokaże, jak to zrobić dla niestandardowego widżetu. Podziękowania należą się Kevinowi Dionowi :)

Sprawdzam, czy mogę dodać stylowalne atrybuty do podstawowej klasy Fragment.

Podstawową ideą jest mieć tę samą funkcjonalność, którą implementuje View podczas obsługi wywołania zwrotnego onClick.

Dodając do odpowiedzi Blundell,
jeśli masz więcej fragmentów, z dużą ilością onClicks:

Czynność:

Fragment someFragment1 = (Fragment)getFragmentManager().findFragmentByTag("someFragment1 "); 
Fragment someFragment2 = (Fragment)getFragmentManager().findFragmentByTag("someFragment2 "); 
Fragment someFragment3 = (Fragment)getFragmentManager().findFragmentByTag("someFragment3 "); 

...onCreate etc instantiating your fragments

public void myClickMethod(View v){
  if (someFragment1.isVisible()) {
       someFragment1.myClickMethod(v);
  }else if(someFragment2.isVisible()){
       someFragment2.myClickMethod(v);
  }else if(someFragment3.isVisible()){
       someFragment3.myClickMethod(v); 
  }

} 

W twoim fragmencie:

  public void myClickMethod(View v){
     switch(v.getid()){
       // Just like you were doing
     }
  } 

Jeśli zarejestrujesz się w xml przy użyciu Androida: Onclick = "", oddzwonienie zostanie przekazane do szanowanego działania, w którego kontekście należy twój fragment (getActivity ()). Jeśli taka metoda nie zostanie znaleziona w działaniu, system zgłosi wyjątek.

Możesz rozważyć użycie EventBus dla zdarzeń oddzielonych od sprzężenia. Możesz bardzo łatwo nasłuchiwać zdarzeń. Możesz także upewnić się, że zdarzenie jest odbierane w wątku interfejsu użytkownika (zamiast wywoływać runOnUiThread .. dla siebie dla każdej subskrypcji zdarzenia)

https://github.com/greenrobot/EventBus

z Github:

Zoptymalizowana pod kątem Androida szyna zdarzeń, która upraszcza komunikację między działaniami, fragmentami, wątkami, usługami itp. Mniej kodu, lepsza jakość

Chciałbym dodać do Adjorn Linkz za odpowiedź .

Jeśli potrzebujesz wielu programów obsługi, możesz po prostu użyć referencji lambda

void onViewCreated(View view, Bundle savedInstanceState)
{
    view.setOnClickListener(this::handler);
}
void handler(View v)
{
    ...
}

Sztuczka polega na tym, że handlerpodpis metody pasuje do View.OnClickListener.onClickpodpisu. W ten sposób nie będziesz potrzebować View.OnClickListenerinterfejsu.

Ponadto nie będziesz potrzebować żadnych instrukcji switch.

Niestety ta metoda jest ograniczona tylko do interfejsów wymagających jednej metody lub lambda.

Chociaż zauważyłem kilka miłych odpowiedzi opartych na wiązaniu danych, nie widziałem, aby takie podejście było w pełnym zakresie - w sensie umożliwienia rozdzielczości fragmentów, jednocześnie pozwalając na definicje układu bez fragmentów w plikach XML.

Zakładając, że powiązanie danych jest włączone, oto ogólne rozwiązanie, które mogę zaproponować; Trochę długi, ale na pewno działa (z pewnymi zastrzeżeniami):

Krok 1: Niestandardowa implementacja OnClick

Spowoduje to uruchomienie wyszukiwania uwzględniającego fragmenty poprzez konteksty powiązane z podsłuchanym widokiem (np. Przycisk):

// CustomOnClick.kt

@file:JvmName("CustomOnClick")

package com.example

import android.app.Activity
import android.content.Context
import android.content.ContextWrapper
import android.view.View
import androidx.fragment.app.Fragment
import androidx.fragment.app.FragmentActivity
import java.lang.reflect.Method

fun onClick(view: View, methodName: String) {
    resolveOnClickInvocation(view, methodName)?.invoke(view)
}

private data class OnClickInvocation(val obj: Any, val method: Method) {
    fun invoke(view: View) {
        method.invoke(obj, view)
    }
}

private fun resolveOnClickInvocation(view: View, methodName: String): OnClickInvocation? =
    searchContexts(view) { context ->
        var invocation: OnClickInvocation? = null
        if (context is Activity) {
            val activity = context as? FragmentActivity
                    ?: throw IllegalStateException("A non-FragmentActivity is not supported (looking up an onClick handler of $view)")

            invocation = getTopFragment(activity)?.let { fragment ->
                resolveInvocation(fragment, methodName)
            }?: resolveInvocation(context, methodName)
        }
        invocation
    }

private fun getTopFragment(activity: FragmentActivity): Fragment? {
    val fragments = activity.supportFragmentManager.fragments
    return if (fragments.isEmpty()) null else fragments.last()
}

private fun resolveInvocation(target: Any, methodName: String): OnClickInvocation? =
    try {
        val method = target.javaClass.getMethod(methodName, View::class.java)
        OnClickInvocation(target, method)
    } catch (e: NoSuchMethodException) {
        null
    }

private fun <T: Any> searchContexts(view: View, matcher: (context: Context) -> T?): T? {
    var context = view.context
    while (context != null && context is ContextWrapper) {
        val result = matcher(context)
        if (result == null) {
            context = context.baseContext
        } else {
            return result
        }
    }
    return null
}

Uwaga: luźno oparty na oryginalnej implementacji Androida (patrz https://android.googlesource.com/platform/frameworks/base/+/a175a5b/core/java/android/view/View.java#3025 )

Krok 2: Deklaratywna aplikacja w plikach układu

Następnie w plikach XML obsługujących wiązanie danych:

<layout>
  <data>
     <import type="com.example.CustomOnClick"/>
  </data>

  <Button
    android:onClick='@{(v) -> CustomOnClick.onClick(v, "myClickMethod")}'
  </Button>
</layout>

Ostrzeżenia

• Zakłada „nowoczesne” FragmentActivitywdrożenie
• Może wyszukiwać tylko metodę „najwyższego” (tj. Ostatniego ) fragmentu na stosie (choć można to naprawić, jeśli to konieczne)

Działa to dla mnie: (Android studio)

 @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {

        View rootView = inflater.inflate(R.layout.update_credential, container, false);
        Button bt_login = (Button) rootView.findViewById(R.id.btnSend);

        bt_login.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {

                System.out.println("Hi its me");


            }// end onClick
        });

        return rootView;

    }// end onCreateView

Najlepsze rozwiązanie IMHO:

we fragmencie:

protected void addClick(int id) {
    try {
        getView().findViewById(id).setOnClickListener(this);
    } catch (Exception e) {
        e.printStackTrace();
    }
}

public void onClick(View v) {
    if (v.getId()==R.id.myButton) {
        onMyButtonClick(v);
    }
}

następnie w Fragmentie onViewStateRestored:

addClick(R.id.myButton);

Twoja aktywność otrzymuje oddzwonienie, które musiało zostać użyte:

mViewPagerCloth.setOnClickListener((YourActivityName)getActivity());

Jeśli chcesz, aby Twój fragment otrzymał wywołanie zwrotne, wykonaj następujące czynności:

mViewPagerCloth.setOnClickListener(this);

i zaimplementuj onClickListenerinterfejs na Fragment