如何处理按钮点击使用片段内的 XML onClick

在“蜂巢”之前(Android 3) ，每个活动都是通过布局的 XML 中的 onClick标签注册来处理按钮点击的:

android:onClick="myClickMethod"

在这个方法中，您可以使用 view.getId()和 switch 语句来完成按钮逻辑。

随着蜂巢的引入，我将这些活动分解成可以在许多不同活动中重用的片段。按钮的大多数行为是独立于活动的，我希望代码驻留在片段文件 没有中，使用旧的(1.6之前)方法为每个按钮注册 OnClickListener。

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

问题是，当我的布局膨胀时，接收按钮点击的仍然是托管活动，而不是单个的片段。有没有一个好的方法

  • 注册片段以接收按钮点击？
  • 将单击事件从 Activity 传递到它们所属的片段？
272382 次浏览
小开
最佳答案

你可以这样做:

活动:

Fragment someFragment;


//...onCreate etc instantiating your fragments


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

片段:

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

@Ameen希望减少耦合，这样Fragments就可以重用了

接口:

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

活动:

XmlClickable someFragment;


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

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

片段:

public class SomeFragment implements XmlClickable {


//...onCreateView, etc.


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

我认为问题在于视图仍然是活动，而不是片段。片段本身没有任何独立的视图，并且附加到父活动视图。这就是为什么事件在活动中结束，而不是在片段中。这是不幸的，但我认为你将需要一些代码使这一工作。

我在转换期间所做的只是添加一个调用旧事件处理程序的单击侦听器。

例如:

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

您可以将回调定义为XML布局的属性。文章自定义Android小部件的自定义XML属性将向你展示如何为一个自定义小部件做到这一点。这要归功于凯文·迪翁。

我正在研究是否可以向基Fragment类添加可样式的属性。

基本思想是在处理onClick回调时具有与View实现的相同的功能。

小开

当使用片段时，我宁愿在代码中使用单击处理，而不是在XML中使用onClick属性。

这在将活动迁移到片段时变得更加容易。你可以直接从每个case块调用点击处理程序(以前在XML中设置为android:onClick)。

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:
...
}
}
}

当涉及到处理片段中的单击时，对我来说这看起来比android:onClick更简单。

小开

我更喜欢使用以下解决方案来处理onClick事件。这也适用于活动和片段。

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;
}
}
}
小开

这是另一种方式:

1.像这样创建一个BaseFragment:

public abstract class BaseFragment extends Fragment implements OnClickListener

2.使用

public class FragmentA extends BaseFragment

而不是

public class FragmentA extends Fragment

3.在活动中:

public class MainActivity extends ActionBarActivity implements OnClickListener

而且

BaseFragment fragment = new FragmentA;


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

希望能有所帮助。

小开

在Blundell的回答中，
如果你有更多的片段，有足够的onClicks:

活动:

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);
}


}

在你的片段中:

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

ButterKnife可能是杂波问题的最佳解决方案。它使用注释处理器来生成所谓的“旧方法”样板代码。

但是onClick方法仍然可以使用，使用自定义充气器。

如何使用

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

实现

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);
}
}
}
}
小开

这对我来说很管用:(Android工作室)

 @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
小开

恕我直言，最佳解决方案:

在片段:

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);
}
}

然后在Fragment的onviewstaterestrestored中:

addClick(R.id.myButton);
小开

如果你使用android:Onclick=""在xml中注册，回调将被给予受尊重的活动，在其上下文中你的片段属于(getActivity())。如果在Activity中没有找到这样的方法，则系统将抛出异常。

小开
你可能想要考虑使用EventBus解耦事件。 你可以很容易地监听事件。你也可以确保事件是在ui线程上接收的(而不是调用runOnUiThread..)

https://github.com/greenrobot/EventBus

从Github:

Android优化事件总线，简化通信之间 活动、片段、线程、服务等等。代码越少越好 质量< / p >

小开

我最近解决了这个问题，而无需向上下文活动添加方法或实现OnClickListener。我也不确定这是否是一个“有效”的解决方案，但它确实有效。

基于:https://developer.android.com/tools/data-binding/guide.html#binding_events

这可以通过数据绑定来完成:只需将你的片段实例作为一个变量添加，然后你就可以用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>

片段链接代码将是…

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;
}


...


}
小开

在我的用例中，我有50个奇怪的imageview，我需要钩子到一个onClick方法。我的解决方案是在片段内循环视图，并在每个视图上设置相同的onclick侦听器:

    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);
}
}
小开

当我看到答案时，它们不知何故很古老。最近谷歌引入了数据绑定，它更容易处理onClick或在xml中赋值。

下面是一个很好的例子，你可以看到如何处理这个问题:

<?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>

还有一个关于数据绑定的很好的教程，你可以在在这里找到它。

小开

你的Activity正在接收必须使用的回调:

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

如果你想让你的片段接收回调，那么这样做:

mViewPagerCloth.setOnClickListener(this);

并在Fragment上实现onClickListener接口

小开

我想添加到Adjorn Linkz的回答。

如果需要多个处理程序，可以只使用lambda引用

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

这里的技巧是handler方法的签名匹配View.OnClickListener.onClick签名。这样，你就不需要View.OnClickListener接口了。

此外，您不需要任何switch语句。

遗憾的是，此方法仅局限于需要单个方法或lambda的接口。

小开

尽管我已经发现了一些依赖于数据绑定的不错的答案，但我还没有看到这种方法能达到完全的程度——在支持片段解析的同时允许XML中的无片段布局定义的意义上。

所以假设数据绑定是启用，这里有一个我可以提出的通用解决方案;有点长，但它肯定有效(有一些注意事项):

步骤1:自定义OnClick实现

这将通过与点击视图相关的上下文(例如按钮)运行片段感知搜索:


// 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
}

注意:松散地基于原来的Android实现(参见https://android.googlesource.com/platform/frameworks/base/+/a175a5b/core/java/android/view/View.java#3025)

步骤2:布局文件中的声明性应用程序

然后，在支持数据绑定的XML中:

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


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

警告

  • 假设一个“现代的”基于FragmentActivity的实现
  • 只能查找堆栈中“最顶层”(即最后的)片段的方法(尽管可以是固定的，如果需要)
小开

下面的解决方案可能是更好的选择。布局在fragment_my.xml中

<?xml version="1.0" encoding="utf-8"?>
<layout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto">


<data>
<variable
name="listener"
type="my_package.MyListener" />
</data>


<androidx.constraintlayout.widget.ConstraintLayout
android:layout_width="match_parent"
android:layout_height="match_parent">
        

<Button
android:id="@+id/moreTextView"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:onClick="@{() -> listener.onClick()}"
android:text="@string/login"
app:layout_constraintTop_toTopOf="parent"
app:layout_constraintLeft_toLeftOf="parent"
app:layout_constraintRight_toRightOf="parent" />
</androidx.constraintlayout.widget.ConstraintLayout>
</layout>

片段是这样的

class MyFragment : Fragment(), MyListener {
override fun onCreateView(
inflater: LayoutInflater,
container: ViewGroup?,
savedInstanceState: Bundle?
): View? {
return FragmentMyBinding.inflate(
inflater,
container,
false
).apply {
lifecycleOwner = viewLifecycleOwner
listener = this@MyFragment
}.root
}


override fun onClick() {
TODO("Not yet implemented")
}


}


interface MyListener{
fun onClick()
}

提交答案