source

Fragments에서 BackPressed()를 구현하는 방법은 무엇입니까?

manycodes 2023. 5. 31. 17:42
반응형

Fragments에서 BackPressed()를 구현하는 방법은 무엇입니까?

우리가 구현할 수 있는 방법이 있습니까?onBackPressed()Android Activity 서구방서 Android Fragment 에사?

에 fragment가 에 fragment가 .onBackPressed()오버라이드할 수 있는 다른 방법이 있습니까?onBackPressed()Android 3.0 fragment 서에?

재정의onBackPressed활동 중입니다. 든모.FragmentTransactionaddToBackStack커밋 전:

@Override
public void onBackPressed() {

    int count = getSupportFragmentManager().getBackStackEntryCount();

    if (count == 0) {
        super.onBackPressed();
        //additional code
    } else {
        getSupportFragmentManager().popBackStack();
    }

}

제 생각에 최선의 해결책은 다음과 같습니다.

JAVA 솔루션

단순 인터페이스 만들기:

public interface IOnBackPressed {
    /**
     * If you return true the back press will not be taken into account, otherwise the activity will act naturally
     * @return true if your processing has priority if not false
     */
    boolean onBackPressed();
}

그리고 당신의 활동에서

public class MyActivity extends Activity {
    @Override public void onBackPressed() {
    Fragment fragment = getSupportFragmentManager().findFragmentById(R.id.main_container);
       if (!(fragment instanceof IOnBackPressed) || !((IOnBackPressed) fragment).onBackPressed()) {
          super.onBackPressed();
       }
    } ...
}

마지막으로 당신의 단편에서:

public class MyFragment extends Fragment implements IOnBackPressed{
   @Override
   public boolean onBackPressed() {
       if (myCondition) {
            //action not popBackStack
            return true; 
        } else {
            return false;
        }
    }
}

KOTL 솔루션

1 - 인터페이스 만들기

interface IOnBackPressed {
    fun onBackPressed(): Boolean
}

2 - 활동 준비

class MyActivity : AppCompatActivity() {
    override fun onBackPressed() {
        val fragment =
            this.supportFragmentManager.findFragmentById(R.id.main_container)
        (fragment as? IOnBackPressed)?.onBackPressed()?.not()?.let {
            super.onBackPressed()
        }
    }
}

3 - 목표 조각에 구현

class MyFragment : Fragment(), IOnBackPressed {
    override fun onBackPressed(): Boolean {
        return if (myCondition) {
            //action not popBackStack
            true
        } else {
            false
        }
    }
}

를 사용하는 androidx.appcompat:appcompat:1.1.0 그 에 는그위추수있다습니가할을 할 수 .OnBackPressedCallback과 같이 에.

requireActivity()
    .onBackPressedDispatcher
    .addCallback(this, object : OnBackPressedCallback(true) {
        override fun handleOnBackPressed() {
            Log.d(TAG, "Fragment back pressed invoked")
            // Do custom work here    

            // if you want onBackPressed() to be called as normal afterwards
            if (isEnabled) {
                isEnabled = false
                requireActivity().onBackPressed()
            }
        }
    }
)

https://developer.android.com/guide/navigation/navigation-custom-back 을 참조하십시오.

@HaMeRed에 따르면 여기서 답변은 작동 방식에 대한 의사 코드입니다.당신의 주요 활동이 다음과 같이 불린다고 가정해 보겠습니다.BaseActivitySlidingMenulib 예제와 같이 하위 조각이 있습니다.다음은 단계입니다.

먼저 일반적인 방법을 사용하기 위해 인터페이스를 구현하는 인터페이스 및 클래스를 만들어야 합니다.

  1. interface 클래스만기들이페터인OnBackPressedListener

    public interface OnBackPressedListener {
    public void doBack();
}

  2. 스을구현클만기의 스킬을 하는 클래스 OnBackPressedListener

    public class BaseBackPressedListener implements OnBackPressedListener {
    private final FragmentActivity activity;

    public BaseBackPressedListener(FragmentActivity activity) {
        this.activity = activity;
    }

    @Override
    public void doBack() {
        activity.getSupportFragmentManager().popBackStack(null, FragmentManager.POP_BACK_STACK_INCLUSIVE);
    }
}

  3. 지금부터, 우리는 우리의 코드를 작업할 것입니다.BaseActivity 그 조각들은 ▁and.

  4. ㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠBaseActivity

    protected OnBackPressedListener onBackPressedListener;

  5. 수신기를 설정하는 메서드 만들기BaseActivity

    public void setOnBackPressedListener(OnBackPressedListener onBackPressedListener) {
    this.onBackPressedListener = onBackPressedListener;
}

  6. 된가.onBackPressed합니다.

    @Override
public void onBackPressed() {
    if (onBackPressedListener != null)
        onBackPressedListener.doBack();
    else
        super.onBackPressed();

  7. 에 있는 에서.onCreateView.

    @Override
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
    activity = getActivity();

    ((BaseActivity)activity).setOnBackPressedListener(new BaseBackPressedListener(activity));

    View view = ... ;
//stuff with view

    return view;
}

Voila, 이제 fragment에서 다시 클릭할 때 당신은 당신의 커스텀 온백 방법을 잡아야 합니다.

이것은 저에게 효과가 있었습니다: https://stackoverflow.com/a/27145007/3934111

@Override
public void onResume() {
    super.onResume();

    if(getView() == null){
        return;
    }

    getView().setFocusableInTouchMode(true);
    getView().requestFocus();
    getView().setOnKeyListener(new View.OnKeyListener() {
        @Override
        public boolean onKey(View v, int keyCode, KeyEvent event) {

            if (event.getAction() == KeyEvent.ACTION_UP && keyCode == KeyEvent.KEYCODE_BACK){
                // handle back button's click listener
                return true;
            }
            return false;
        }
    });
}

이러한 기능을 사용하려면 작업에서 해당 기능을 재정의한 다음YourBackPressed모든 fragment에 대한 인터페이스로, 뒤로 버튼을 누를 때마다 관련 fragment에 대해 호출합니다.

편집: 이전 답변을 첨부합니다.

오늘 이 작업을 수행할 경우 브로드캐스트를 사용하거나 다른 패널이 마스터/기본 컨텐츠 패널에 동시에 업데이트될 것으로 예상되는 경우 주문된 브로드캐스트를 사용합니다.

LocalBroadcastManager 지원 라이브러리에서 이것을 도울 수 있고, 당신은 그냥 방송을 보냅니다.onBackPressed당신의 단편에 관심 있는 것을 구독하세요.메시징은 더 분리된 구현이며 확장성이 더 좋을 것이므로 이제 공식적인 구현 권장 사항이 될 것입니다.사용하기만 하면 됩니다.Intent사용자의 메시지에 대한 필터 역할을 수행합니다.새로 작성한 파일 전송ACTION_BACK_PRESSED당신의 활동에서 그것을 보내고 관련된 단편에서 그것을 듣습니다.

이 중 어느 것도 구현하기 쉽지 않으며 최적의 방식으로 작동하지도 않습니다.

fragments에는 작업을 수행할 메서드 호출이 있습니다.

@Override
    public void onDetach() {
        super.onDetach();
        PUT YOUR CODE HERE
    }

이것이 그 일을 할 것입니다.

구글이 새로운 API를 출시했습니다.onBackPressedFragment:

activity?.onBackPressedDispatcher?.addCallback(viewLifecycleOwner, object : OnBackPressedCallback(true) {
            override fun handleOnBackPressed() {

            }
        })

더 롭고더나접근방식은의 것: 의코부을따릅니다분.Fragment백 프레스 이벤트를 캡처하는 데 도움이 됩니다.

JAVA

@Override
public void onAttach(@NonNull Context context) {
    super.onAttach(context);

    OnBackPressedCallback callback = new OnBackPressedCallback(true) {
        @Override
        public void handleOnBackPressed() {
            Toast.makeText(mContext, "back pressed", Toast.LENGTH_SHORT).show();
            
            // And when you want to go back based on your condition
            if (yourCondition) {
                this.setEnabled(false);
                requireActivity().onBackPressed();
            }
        }
    };

    requireActivity().getOnBackPressedDispatcher().addCallback(this, callback);
}

코틀린

activity?.onBackPressedDispatcher?.addCallback(viewLifecycleOwner, object : OnBackPressedCallback(true) {
    override fun handleOnBackPressed() {

    }
})

그냥추를 추가하세요.addToBackStack: 아와같 fragment 간환전는안동하에이래::

fragmentManager.beginTransaction().replace(R.id.content_frame,fragment).addToBackStack("tag").commit();

를 쓰면addToBackStack(null)그것은 그것을 스스로 처리할 것이지만, 만약 당신이 태그를 준다면, 당신은 그것을 수동으로 처리해야 합니다.

탐색 구성 요소를 사용하여 다음과 같이 수행할 수 있습니다.

자바

public class MyFragment extends Fragment {

@Override
public void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    // This callback will only be called when MyFragment is at least Started.
    OnBackPressedCallback callback = new OnBackPressedCallback(true /* enabled by default */) {
        @Override
        public void handleOnBackPressed() {
            // Handle the back button event
        }
    });
    requireActivity().getOnBackPressedDispatcher().addCallback(this, callback);

    // The callback can be enabled or disabled here or in handleOnBackPressed()
}
...
}

코틀린

class MyFragment : Fragment() {

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)

    // This callback will only be called when MyFragment is at least Started.
    val callback = requireActivity().onBackPressedDispatcher.addCallback(this) {
        // Handle the back button event
    }

    // The callback can be enabled or disabled here or in the lambda
}
...
}

이 질문과 답변 중 일부는 5년이 넘었기 때문에, 저의 해결책을 공유하겠습니다.이것은 @oyenigun의 답변에 대한 후속 조치이자 현대화입니다.

업데이트: 이 기사의 하단에서 활동을 전혀 포함하지 않는 추상적인 조각 확장을 사용하는 대체 구현을 추가했는데, 이는 서로 다른 등 동작이 필요한 중첩 조각과 관련된 더 복잡한 조각 계층을 가진 모든 사람에게 유용할 것입니다.

사용하는 일부 조각은 팝업되는 작은 정보 보기와 같이 뒤로 단추를 눌러 무시하고 싶은 작은 보기가 있기 때문에 이 기능을 구현해야 했지만, 이 기능은 뒤로 단추의 동작을 재정의해야 하는 모든 사용자에게 유용합니다.

먼저, 인터페이스 정의

public interface Backable {
    boolean onBackPressed();
}

이 인터페이스는, 내가 부르는 것입니다.Backable 규칙에 입니다), (저는명규엄사격다니람입있다습니방이법한칙에단명일▁(저▁(▁method▁a다),▁single▁has있습니▁conv▁naming),)이 있습니다.onBackPressed()그것은 반드시 a를 반환해야 합니다.booleanvalue.이벤트를 "흡수 값을 . 뒤로 버튼 누름이 뒤로 이벤트를 "흡수"했는지 여부를 알아야 하므로 부울 값을 적용해야 합니다.true 않으면 더 의 조치가하지 않습니다. 그렇지 않으면,false기본 백 액션이 여전히 수행되어야 한다고 말합니다.이 인터페이스는 자체 파일이어야 합니다(가능하면 이름이 지정된 별도의 패키지에 포함됨).interfaces기억하세요, 당신의 수업을 패키지로 나누는 것은 좋은 연습입니다.

둘째, 맨 위의 조각을 찾습니다.

▁the▁that▁method다▁returns니▁a▁last를 반환하는 메소드를 만들었습니다.Fragment개체가 백스택에 있습니다.태그를 사용합니다...ID를 사용하는 경우 필요한 내용을 변경합니다.유틸리티 클래스에서 내비게이션 상태 등을 다루는 정적 방법이 있습니다.물론, 당신에게 가장 적합한 곳에 두세요.교육을 위해, 저는 제 것을 '라는 수업에 넣었습니다.NavUtils.

public static Fragment getCurrentFragment(Activity activity) {
    FragmentManager fragmentManager = activity.getFragmentManager();
    if (fragmentManager.getBackStackEntryCount() > 0) {
        String lastFragmentName = fragmentManager.getBackStackEntryAt(
                fragmentManager.getBackStackEntryCount() - 1).getName();
        return fragmentManager.findFragmentByTag(lastFragmentName);
    }
    return null;
}

하고, 경우에는 " " " 0" 입니다. 그렇지 않으면ArrayOutOfBoundsException런타임에 느려질 수 있습니다. null0을 합니다.보다 크지 않으면 null을 반환합니다.null 값은 나중에 확인합니다.

셋째, 단편적으로 구현

» Backable뒤로 단추 동작을 재정의해야 하는 부분의 인터페이스입니다.구현 방법을 추가합니다.

public class SomeFragment extends Fragment implements 
        FragmentManager.OnBackStackChangedListener, Backable {

...

    @Override
    public boolean onBackPressed() {

        // Logic here...
        if (backButtonShouldNotGoBack) {
            whateverMethodYouNeed();
            return true;
        }
        return false;
    }

}

onBackPressed()오버라이드, 필요한 논리는 무엇이든 넣으십시오.뒤로 버튼을 눌러 뒤로 스택을 열지 않으려면(기본 동작) 뒤로 이벤트가 흡수되었음을 true로 반환합니다.그렇지 않으면 false를 반환합니다.

마지막으로, 활동에서...

를 합니다.onBackPressed()메서드를 사용하여 다음 논리를 추가합니다.

@Override
public void onBackPressed() {

    // Get the current fragment using the method from the second step above...
    Fragment currentFragment = NavUtils.getCurrentFragment(this);

    // Determine whether or not this fragment implements Backable
    // Do a null check just to be safe
    if (currentFragment != null && currentFragment instanceof Backable) {

        if (((Backable) currentFragment).onBackPressed()) {
            // If the onBackPressed override in your fragment 
            // did absorb the back event (returned true), return
            return;
        } else {
            // Otherwise, call the super method for the default behavior
            super.onBackPressed();
        }
    }

    // Any other logic needed...
    // call super method to be sure the back button does its thing...
    super.onBackPressed();
}

백스택에서 , 그것이 의 "fragment"를 합니다.Backable 합니다.이 경우 이벤트가 흡수되었는지 확인합니다.만약 그렇다면, 우리는 끝입니다.onBackPressed()돌아올 수 있습니다.그렇지 않으면 일반적인 백프레스로 처리하고 슈퍼 메소드를 호출합니다.

활동을 포함하지 않는 두 번째 옵션

때로는 활동에서 이 문제를 전혀 처리하지 않고 조각 내에서 직접 처리해야 합니다.하지만 누가 당신이 백프레스 API를 가진 프래그먼트를 가질 수 없다고요?조각을 새 클래스로 확장하십시오.

하고 Fragment를 .View.OnKeyListner인터페이스...

import android.app.Fragment;
import android.os.Bundle;
import android.view.KeyEvent;
import android.view.View;

public abstract class BackableFragment extends Fragment implements View.OnKeyListener {

    @Override
    public void onViewCreated(View view, Bundle savedInstanceState) {
        super.onViewCreated(view, savedInstanceState);
        view.setFocusableInTouchMode(true);
        view.requestFocus();
        view.setOnKeyListener(this);
    }

    @Override
    public boolean onKey(View v, int keyCode, KeyEvent event) {
        if (event.getAction() == KeyEvent.ACTION_UP) {
            if (keyCode == KeyEvent.KEYCODE_BACK) {
                onBackButtonPressed();
                return true;
            }
        }

        return false;
    }

    public abstract void onBackButtonPressed();
}

보시는 바와 같이, 확장되는 모든 조각들은BackableFragment으로 하사여자클다릭다니합시를 하여 뒤로 을 캡처합니다.View.OnKeyListener인터페이스추상적인 것을 부르세요.onBackButtonPressed()된 구된내방법 내에서 .onKey()뒤로 버튼 누름을 식별하기 위해 표준 로직을 사용하는 방법.뒤로 버튼 이외의 키 클릭을 등록해야 하는 경우에는 다음 번호로 전화하십시오.super을 할 때 onKey()그렇지 않으면 추상화의 동작을 무시할 수 있습니다.

사용이 간편하고 확장 및 구현만 가능:

public class FragmentChannels extends BackableFragment {

    ...

    @Override
    public void onBackButtonPressed() {
        if (doTheThingRequiringBackButtonOverride) {
            // do the thing
        } else {
            getActivity().onBackPressed();
        }
    }

    ...
}

onBackButtonPressed()이며, 은 슈퍼클방추상다니입적법을 해야 합니다. 일단 확장하면 구현해야 합니다.onBackButtonPressed()를 합니다.void단편 클래스 내에서 작업을 수행하기만 하면 되고, 프레스의 흡수를 다시 활동으로 전달할 필요가 없기 때문입니다.활동을 호출해야 합니다.onBackPressed()방법은 뒤로 단추를 사용하여 작업하는 것이 필요하지 않으면 뒤로 단추를 사용할 수 없습니다.그리고 당신은 그것을 원하지 않습니다!

경고 이렇게 하면 플래그먼트의 루트 보기에 대한 키 수신기가 설정되므로 이에 초점을 맞춰야 합니다.이 클래스를 확장하는 조각(또는 동일한 다른 내부 조각 또는 보기)에 관련된 편집 텍스트(또는 다른 포커스 스틸 보기)가 있는 경우에는 이를 별도로 처리해야 합니다.편집 텍스트를 확장하여 백프레스에 대한 초점을 잃었다는 좋은 기사가 있습니다.

누군가가 이것을 유용하게 생각하기를 바랍니다.해피 코딩.

솔루션은 간단합니다.

  1. 모든 fragment가 확장되는 기본 fragment 클래스가 있으면 해당 클래스에 이 코드를 추가하고, 그렇지 않으면 해당 기본 fragment 클래스를 만듭니다.
/* 
* called when on back pressed to the current fragment that is returned
*/
public void onBackPressed()
{
    // add code in super class when override
}
  1. 에서 활동클서재의를 합니다.onBackPressed다음과 같이:
private BaseFragment _currentFragment;

@Override
public void onBackPressed()
{
      super.onBackPressed();
     _currentFragment.onBackPressed();
}
  1. Fragment 클래스에서 원하는 코드를 추가합니다.
@Override
public void onBackPressed()
{
    setUpTitle();
}

코틀린에서는 훨씬 더 간단합니다.

override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
    requireActivity().onBackPressedDispatcher.addCallback(viewLifecycleOwner, object : OnBackPressedCallback(true) {
        override fun handleOnBackPressed() {
            //
        }
    })
}

onBackPressed()조각이 활동에서 분리되도록 합니다.

@Stelling Diaz의 답변에 따르면 그가 옳다고 생각합니다. 하지만 몇몇 상황은 틀릴 것입니다. (예: 화면 회전)

그래서, 제 생각에 우리가 발견할 수 있는 것은isRemoving()목표를 달성하기 위해.

다음 주소로 작성할 수 있습니다.onDetach()또는onDestroyView()그것은 일입니다. 

@Override
public void onDetach() {
    super.onDetach();
    if(isRemoving()){
        // onBackPressed()
    }
}

@Override
public void onDestroyView() {
    super.onDestroyView();
    if(isRemoving()){
        // onBackPressed()
    }
}

fragment의 onCreate 메서드 안에 다음을 추가합니다.

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    OnBackPressedCallback callback = new OnBackPressedCallback(true) {
        @Override
        public void handleOnBackPressed() {
            //Handle the back pressed
        }
    };
    requireActivity().getOnBackPressedDispatcher().addCallback(this, callback);
}

아래와 같이 프로젝트에 인터페이스를 추가해야 합니다.

public interface OnBackPressed {

     void onBackPressed();
}

그런 다음 이 인터페이스를 단편에 구현해야 합니다.

public class SampleFragment extends Fragment implements OnBackPressed {

    @Override
    public void onBackPressed() {
        //on Back Pressed
    }

}

또한 아래와 같이 BackPressed 이벤트에 대한 작업에서 BackPressed 이벤트에 이를 트리거할 수 있습니다.

public class MainActivity extends AppCompatActivity {
       @Override
        public void onBackPressed() {
                Fragment currentFragment = getSupportFragmentManager().getFragments().get(getSupportFragmentManager().getBackStackEntryCount() - 1);
                if (currentFragment instanceof OnBackPressed) {  
                    ((OnBackPressed) currentFragment).onBackPressed();
                }
                super.onBackPressed();
        }
}

EventBus를 사용하는 경우 훨씬 더 간단한 솔루션일 것입니다.

파편 속:

@Override
public void onAttach(Activity activity) {
    super.onAttach(activity);
    EventBus.getDefault().register(this);
}

@Override
public void onDetach() {
    super.onDetach();
    EventBus.getDefault().unregister(this);
}


// This method will be called when a MessageEvent is posted
public void onEvent(BackPressedMessage type){
    getSupportFragmentManager().popBackStack();
}

활동 클래스에서 다음을 정의할 수 있습니다.

@Override
public void onStart() {
    super.onStart();
    EventBus.getDefault().register(this);
}

@Override
public void onStop() {
    EventBus.getDefault().unregister(this);
    super.onStop();
}

// This method will be called when a MessageEvent is posted
public void onEvent(BackPressedMessage type){
    super.onBackPressed();
}

@Override
public void onBackPressed() {
    EventBus.getDefault().post(new BackPressedMessage(true));
}

뒤로 누른 메시지입니다.java는 POJO 객체일 뿐입니다.

이것은 매우 깔끔하며 인터페이스/구현에 번거로움이 없습니다.

음, 저는 이렇게 했고, 그것은 저에게 효과가 있습니다.

단순 인터페이스

FragmentOnBackClickInterface.java

public interface FragmentOnBackClickInterface {
    void onClick();
}

구현 예제

MyFragment.java 

public class MyFragment extends Fragment implements FragmentOnBackClickInterface {

// other stuff

public void onClick() {
       // what you want to call onBackPressed?
}

활동 중에 BackPressed를 덮어씁니다.

    @Override
public void onBackPressed() {
    int count = getSupportFragmentManager().getBackStackEntryCount();
    List<Fragment> frags = getSupportFragmentManager().getFragments();
    Fragment lastFrag = getLastNotNull(frags);
    //nothing else in back stack || nothing in back stack is instance of our interface
    if (count == 0 || !(lastFrag instanceof FragmentOnBackClickInterface)) {
        super.onBackPressed();
    } else {
        ((FragmentOnBackClickInterface) lastFrag).onClick();
    }
}

private Fragment getLastNotNull(List<Fragment> list){
    for (int i= list.size()-1;i>=0;i--){
        Fragment frag = list.get(i);
        if (frag != null){
            return frag;
        }
    }
    return null;
}

이것이 내 해결책입니다.

My Activity.java에서:

public interface OnBackClickListener {
        boolean onBackClick();
    }

    private OnBackClickListener onBackClickListener;

public void setOnBackClickListener(OnBackClickListener onBackClickListener) {
        this.onBackClickListener = onBackClickListener;
    }

@Override
    public void onBackPressed() {
        if (onBackClickListener != null && onBackClickListener.onBackClick()) {
            return;
        }
        super.onBackPressed();
    }

토막글:

((MyActivity) getActivity()).setOnBackClickListener(new MyActivity.OnBackClickListener() {
    @Override
    public boolean onBackClick() {
        if (condition) {
            return false;
        }

        // some codes

        return true;
    }
});

public class MyActivity extends Activity {

    protected OnBackPressedListener onBackPressedListener;

    public interface OnBackPressedListener {
        void doBack();
    }

    public void setOnBackPressedListener(OnBackPressedListener onBackPressedListener) {
        this.onBackPressedListener = onBackPressedListener;
    }

    @Override
    public void onBackPressed() {
        if (onBackPressedListener != null)
            onBackPressedListener.doBack();
        else
            super.onBackPressed();
    } 

    @Override
    protected void onDestroy() {
        onBackPressedListener = null;
        super.onDestroy();
    }
}

당신의 단편에 다음을 추가하세요, 주요 활동의 인터페이스를 구현하는 것을 잊지 마세요.

public class MyFragment extends Framgent implements MyActivity.OnBackPressedListener {
    @Override
    public void onViewCreated(View view, Bundle savedInstanceState) {
        super.onViewCreated(view, savedInstanceState);
         ((MyActivity) getActivity()).setOnBackPressedListener(this);
    }

@Override
public void doBack() {
    //BackPressed in activity will call this;
}

}

이것은 작은 코드일 뿐입니다.

 getActivity().onBackPressed();

누군가에게 도움이 되길 바랍니다 :)

사용할 수 있습니다.onBackPressedDispatcher다음과 같은 부모 활동:

val backpress = requireActivity().onBackPressedDispatcher.addCallback(viewLifecycleOwner, true) {
            // here dispatcher works for any action when back pressed
}

다음과 같은 경우 언제든지 fragment에서 backpress 버튼을 활성화/비활성화할 수 있습니다.

backpress.isEnabled = true/false

 requireActivity().onBackPressedDispatcher.addCallback(viewLifecycleOwner) {
        //your code 
    }

UPDATE:를 사용해야 합니다.

사용 방법은 developer.android.com/guide/navigation/navigation-custom-back 에서 확인할 수 있습니다.

백프레스를 처리하기 위해 활동에 단편을 등록할 수 있습니다.

interface BackPressRegistrar {
    fun registerHandler(handler: BackPressHandler)
    fun unregisterHandler(handler: BackPressHandler)
}

interface BackPressHandler {
    fun onBackPressed(): Boolean
}

용도:

조각 내:

private val backPressHandler = object : BackPressHandler {
    override fun onBackPressed(): Boolean {
        showClosingWarning()
        return false
    }
}

override fun onResume() {
    super.onResume()
    (activity as? BackPressRegistrar)?.registerHandler(backPressHandler)
}

override fun onStop() {
    (activity as? BackPressRegistrar)?.unregisterHandler(backPressHandler)
    super.onStop()
}

활동 중:

class MainActivity : AppCompatActivity(), BackPressRegistrar {


    private var registeredHandler: BackPressHandler? = null
    override fun registerHandler(handler: BackPressHandler) { registeredHandler = handler }
    override fun unregisterHandler(handler: BackPressHandler) { registeredHandler = null }

    override fun onBackPressed() {
        if (registeredHandler?.onBackPressed() != false) super.onBackPressed()
    }
}

@Override
public void onResume() {
    super.onResume();

    getView().setFocusableInTouchMode(true);
    getView().requestFocus();
    getView().setOnKeyListener(new View.OnKeyListener() {
        @Override
        public boolean onKey(View v, int keyCode, KeyEvent event) {
            if (event.getAction() == KeyEvent.ACTION_UP && keyCode == KeyEvent.KEYCODE_BACK) {
                // handle back button
                replaceFragmentToBackStack(getActivity(), WelcomeFragment.newInstance(bundle), tags);

                return true;
            }

            return false;
        }
    });
}

이제 BackPressed에서 처리하여 사용자 지정 백 네비게이션을 제공하는 것이 fragment 내부의 콜백으로 더 쉬워졌습니다.

class MyFragment : Fragment() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        val onBackPressedCallback = object : OnBackPressedCallback(true) {
            override fun handleOnBackPressed() {
                if (true == conditionForCustomAction) {
                    myCustomActionHere()
                } else  NavHostFragment.findNavController(this@MyFragment).navigateUp();    
        }
    }
    requireActivity().onBackPressedDispatcher.addCallback(
        this, onBackPressedCallback
    )
    ...
}

어떤 조건에 따라 기본 백업 작업을 수행하려면 다음을 사용할 수 있습니다.

 NavHostFragment.findNavController(this@MyFragment).navigateUp();

DestroyView()에서 를 사용하는 것은 어떻습니까?

@Override
public void onDestroyView() {
    super.onDestroyView();
}

다음 단계를 수행합니다.

조각을 추가할 때 항상

fragmentTransaction.add(R.id.fragment_container, detail_fragment, "Fragment_tag").addToBackStack(null).commit();

그런 다음 주 활동에서 오버라이드합니다.onBackPressed()

if (getSupportFragmentManager().getBackStackEntryCount() > 0) {
    getSupportFragmentManager().popBackStack();
} else {
    finish();
}

당신의 앱에서 뒤로 버튼을 처리하기 위해,

Fragment f = getActivity().getSupportFragmentManager().findFragmentByTag("Fragment_tag");
if (f instanceof FragmentName) {
    if (f != null) 
        getActivity().getSupportFragmentManager().beginTransaction().remove(f).commit()               
}

바로 그거야!

매우 짧고 달콤한 대답:

getActivity().onBackPressed();

내 경우의 전체 시나리오에 대한 설명:

주 작업에 Fragment A가 있으며 Fragment A에서 Fragment B를 엽니다(Fragment B는 Fragment A의 하위 또는 중첩된 fragment).

 Fragment duedateFrag = new FragmentB();
 FragmentTransaction ft  = getFragmentManager().beginTransaction();
 ft.replace(R.id.container_body, duedateFrag);
 ft.addToBackStack(null);
 ft.commit();

만약 에서 프래그먼트 , 만, 당, 약, 자, 당을 넣으면 됩니다.getActivity().onBackPressed();단편 B에서.

언급URL : https://stackoverflow.com/questions/5448653/how-to-implement-onbackpressed-in-fragments

반응형

'source' 카테고리의 다른 글

아이폰에 호스트 파일이 있습니까?어떻게 바꿀까요?  (0) 2023.05.31
SCHEMA에서 GRANT USAGE는 정확히 어떤 역할을 합니까?  (0) 2023.05.31
MongoDB용 C# 드라이버를 사용하여 주문 또는 정렬을 지정하는 방법은 무엇입니까?  (0) 2023.05.31
응용 프로그램을 업데이트하려고 할 때 [INSTALL_FAILED_ALREADY_EXIST] 오류가 발생함  (0) 2023.05.31
SQL 대비 Azure 스토리지 테이블  (0) 2023.05.31

'source'의 다른글

  • 현재글Fragments에서 BackPressed()를 구현하는 방법은 무엇입니까?

관련글

댓글

티스토리툴바