Fragments 내에서 XML onClick을 사용하여 버튼 클릭을 처리하는 방법

Pre-Honeycomb (Android 3)에서 각 활동은 onClick레이아웃의 XML에서 태그를 통한 버튼 클릭을 처리하도록 등록되었습니다 .

android:onClick="myClickMethod"

이 방법 내 view.getId()에서 버튼 논리를 수행하기 위해 및 switch 문을 사용할 수 있습니다 .

Honeycomb을 도입하면서 이러한 활동을 여러 활동 내에서 재사용 할 수있는 조각으로 나누고 있습니다. 버튼의 대부분의 동작은 활동과 무관 하며 각 버튼에 대한 이전 (1.6 이전) 방법을 사용 하지 않고 코드가 Fragments 파일 내에 있어야 OnClickListener합니다.

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

문제는 내 레이아웃이 팽창 될 때 개별 조각이 아닌 버튼 클릭을받는 호스팅 활동이라는 것입니다. 다음 중 하나에 대한 좋은 접근 방법이 있습니까?

• 버튼 클릭을 받기 위해 프래그먼트를 등록 하시겠습니까?
• 클릭 이벤트를 활동에서 그들이 속한 조각으로 전달합니까?

당신은 이것을 할 수 있습니다 :

활동:

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

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

내가 생각하는 문제는보기가 여전히 조각이 아니라 활동이라는 것입니다. 프래그먼트는 자체에 대한 독립적 인 관점을 가지고 있지 않으며 상위 활동보기에 첨부됩니다. 그렇기 때문에 이벤트가 조각이 아닌 활동에서 종료됩니다. 불행한 일이지만이 작업을 수행하려면 코드가 필요하다고 생각합니다.

전환 중에 내가 한 일은 단순히 기존 이벤트 핸들러를 호출하는 클릭 리스너를 추가하는 것입니다.

예를 들어 :

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

최근 컨텍스트 활동에 메소드를 추가하거나 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;
    }

    ...

}

버터 나이프 는 어수선한 문제에 대한 최상의 솔루션 일 것입니다. 주석 프로세서를 사용하여 소위 "이전 방법"상용구 코드를 생성합니다.

그러나 맞춤형 팽창기와 함께 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);
            }
        }
    }
}

onClick조각으로 작업 할 때 XML 에서 속성을 사용하는 것보다 코드에서 클릭 처리를 원합니다 .

활동을 단편으로 마이그레이션 할 때 훨씬 쉬워집니다. android:onClick각 case블록 에서 직접 클릭 핸들러 (이전 에는 XML로 설정 됨)를 호출하면 됩니다.

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.

이것은 다른 방법입니다.

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

도움이 되길 바랍니다.

내 유스 케이스에는 단일 onClick 메소드에 연결하는 데 필요한 50 개의 이상한 ImageView가 있습니다. 내 솔루션은 조각 내부의 뷰를 반복하고 각각에 동일한 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);
        }
    }

내가 대답을 볼 때 그들은 어떻게 든 오래된 것입니다. 최근 Google 은 XML에서 onClick 또는 할당 을 훨씬 쉽게 처리 할 수있는 DataBinding 을 도입했습니다 .

다음은 이것을 처리하는 방법을 볼 수있는 좋은 예입니다.

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

여기에서 찾을 수있는 DataBinding에 대한 매우 유용한 자습서도 있습니다 .

콜백을 XML 레이아웃의 속성으로 정의 할 수 있습니다. 사용자 정의 Android 위젯에 대한 사용자 정의 XML 속성 기사 는 사용자 정의 위젯에 대해 수행하는 방법을 보여줍니다. 신용은 Kevin Dion에게 간다 :)

기본 Fragment 클래스에 스타일 속성을 추가 할 수 있는지 여부를 조사하고 있습니다.

기본 아이디어는 onClick 콜백을 처리 할 때 View와 동일한 기능을 갖는 것입니다.

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

android : Onclick = ""을 사용하여 xml에 등록하면 조각이 속한 컨텍스트 (getActivity ())에서 존경받는 Activity에 콜백이 제공됩니다. 그러한 방법이 활동에서 발견되지 않으면 시스템은 예외를 던집니다.

분리 된 이벤트에 EventBus를 사용하는 것을 고려할 수 있습니다. 이벤트를 매우 쉽게들을 수 있습니다. 모든 이벤트 구독에 대해 runOnUiThread ..를 호출하는 대신 UI 스레드에서 이벤트가 수신되는지 확인할 수도 있습니다.

https://github.com/greenrobot/EventBus

Github에서 :

활동, 프래그먼트, 스레드, 서비스 등의 통신을 단순화하는 Android 최적화 이벤트 버스. 코드가 적고 품질이 우수합니다.

Adjorn Linkz의 답변 에 추가하고 싶습니다 .

여러 핸들러가 필요한 경우 람다 참조 만 사용할 수 있습니다.

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

여기서 트릭은 handler메소드의 서명이 서명과 일치 한다는 것 View.OnClickListener.onClick입니다. 이런 식으로 View.OnClickListener인터페이스 가 필요하지 않습니다 .

또한 switch 문이 필요하지 않습니다.

안타깝게도이 방법은 단일 방법 또는 람다가 필요한 인터페이스로만 제한됩니다.

데이터 바인딩에 의존하는 멋진 답변을 발견했지만 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기반 구현을 가정
• 스택에서 "최상위" 조각 (즉, 마지막 ) 조각 의 조회 방법 만 가능 ( 필요한 경우 수정할 수 있음)

이것은 나를 위해 일하고있다 : (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

최고의 솔루션 IMHO :

조각으로 :

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의 onViewStateRestored에서 :

addClick(R.id.myButton);

액티비티는 다음과 같이 콜백을 받고 있습니다.

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

프래그먼트가 콜백을 수신하도록하려면 다음을 수행하십시오.

mViewPagerCloth.setOnClickListener(this);

onClickListenerFragment에 인터페이스를 구현하십시오.