Kyle's Life Lab

당연히 Activity와는 다른 생명주기를 갖기때문에 fragment를 사용하는 개념은 액티비티와는 완전히 다르다. 모든 것은 FragmentManager를 통해 독립적으로 관리된다. 액티비티는 UI중심 즉 각각의 layout파일 중심으로 작동하면 된다고 생각하면되나 fragment는 fragmentManager중심이라고 생각하는 것이 맞다.

한 가지 예를 들어보자면 fragment는 혼자서 보일수는 없다 반드시 액티비티에 포함되어야한다. 하지만 그렇다고 해도 액티비티가 다시 생성되어서 모든 정보가 초기화되어도 fragmentManager에 기록된 정보는 그대로 살아 있다. 액티비티가 onCreate부터 다시 불리더라도 이전에 만들어서 fragmentManager에 add해둔 fragment는 아직 살아있다는 것이다. 

fragment를 포함하고 있는 Activity가 onCreate부터 다시불려초기화 되어도 add된 fragment들이 살아 있는 이유는 생명주기 자체가 따로 관리 되기 때문이다.

- Fragment LifeCycle(출처 android:Reference)

onAttach()(Activity Layout에 추가된 순간 호출! )부터 onResume()되면 화면에 display 되게 되고 onDetach되어 FragmentManager에서 사라질때까지 display되게 된다.

Fragment 생명주기에 대한 자세한 설명

http://blog.saltfactory.net/190

http://nkstudy.tistory.com/1

언제든 잘못된 설명은 말씀해주세요^^

fragmentManager에 추가된 fragment를 어떻게 떼어내어 다시 fragment로 만들수 있을까? 혹은 이미 있는 fragment를 어떻게 다시 붙일수 있을까? 이때 attach와 detach메소드가 있다.

먼저 reference를 보자 

public abstract FragmentTransaction attach (Fragment fragment)

public abstract FragmentTransaction detach (Fragment fragment)

보면 attach보다 detach를 먼저 사용하도록 되어있다. detach는 UI로부터 fragment를 떼어내는 것이고 attach는 그것을 다시 UI에 붙인다는 의미이다. 이것을 제대로 사용하는 예제는 tab fragment소스에 찾아볼수 있다.

        @Override
        public void onTabChanged(String tabId) {
            TabInfo newTab = mTabs.get(tabId);	// 넣어놨던 tabinfo찾아온다.
            if (mLastTab != newTab) {//라스트탭이 뉴탭과 같지 않다면
                FragmentTransaction ft = mActivity.getSupportFragmentManager().beginTransaction();
                if (mLastTab != null) {	//라스트탭이 널이 아니면
                    if (mLastTab.fragment != null) {	//라스트탭의 프래그먼트가 널이 아니면
                        ft.detach(mLastTab.fragment);	//떼어낸다
                    }
                }
                if (newTab != null) {	// 뉴탭이 널이 아니면
                    if (newTab.fragment == null) {	//프래그먼트가 널이면
                        newTab.fragment = Fragment.instantiate(mActivity,
                                newTab.clss.getName(), newTab.args);//새로 만들어준다
                        ft.add(mContainerId, newTab.fragment, newTab.tag);	//추가해준다
                    } else {
                        ft.attach(newTab.fragment);	//널이 아니면 그대로 붙여준다.
                    }
                }

                mLastTab = newTab;	//새로운탭이 라스트탭이 된다.
                ft.commit();
                mActivity.getSupportFragmentManager().executePendingTransactions();
            }
        }

위에 소스처럼 detach로 잘떼어놨다가 다시 attach로 붙여준다.

이것만 봐도 위에서 설명한 것처럼 Activity와는 사용하는 방법, 개념이 완전히 다르고 조금 더 유동적을 사용할 수 있다는 것을 알수 있다. 

그런데 여기서 한가지 생기는 의문은 fragmentTransaction에는 add, remove와 같은 메소드도 있다. 이것을 왜 사용하지 않았을까? 내가 보기에는 자원 재활용과 fragment정보 유지라는 생각이 들었다. add와 remove를 반복적으로 사용하려면 fragment를 계속 동적으로 생성하고 지우고를 반복해야한다. 그리고 위의 예제처럼 TabInfo라는 자료형을 만들어 fragment를 유지한다면 그안의 정보도 유지될것으로 보인다.

그런데 이 detach메소드가 작동하지 않은경우가 있다. 바로 정적으로 fragment가 선언된 경우이다.

xml 파일로 아래와 같이 class가 지정되어 fragment가 선언된경우에는 detach, remove모두 작동하지 않는다.

###. Fragment생명주기에 onAttach, onDetach라는 콜백메소드가 있어 attach(), detach()메소드 실행시 이 콜백메소드들을 호출하지 않을까 했지만 호출하지는 않았다.

언제든 틀린 설명은 말씀해주세요^^

@Override
	public void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		requestWindowFeature(Window.FEATURE_NO_TITLE);
		setContentView(R.layout.activity_main);

		Log.e("온크리에이트", "입니다.");

		if(getSupportFragmentManager().findFragmentByTag("listfra") == null){
			FragmentTransaction ft = getSupportFragmentManager().beginTransaction();
			ListViewFragment lvf = new ListViewFragment();
			ft.add(R.id.menu, lvf, "listfra");
			ft.addToBackStack(null);
			ft.commit();
			
		}

	}

fragment 코드들을 보다보면 이렇게 onCreate안에 fragment 를 추가해주는 코드들을 볼수 있는데 저렇게 처음부터 null인지 체크를 한다. 이것은 이 액티비티가 처음 실행되었을 때가 아닌 다음번에 실행했을 때를 대비한 코드다. fragment가 이미 생성되어있다면 같은 fragment를 manager에 커밋할필요가 없기때문에 없는 경우에만 프래그먼트를 만들게 한다. 그렇지 않으면 중복해서 만들어서 표시하게된다.

MainActivity.java

package com.example.hellotabfragment;

import java.util.HashMap;

import android.content.Context;
import android.os.Bundle;
import android.support.v4.app.Fragment;
import android.support.v4.app.FragmentActivity;
import android.support.v4.app.FragmentTransaction;
import android.util.Log;
import android.view.View;
import android.widget.TabHost;

import com.example.hellotabfragment.fragment.Fragment1;
import com.example.hellotabfragment.fragment.Fragment2;
import com.example.hellotabfragment.fragment.Fragment3;

/**
 * This demonstrates how you can implement switching between the tabs of a
 * TabHost through fragments.  It uses a trick (see the code below) to allow
 * the tabs to switch between fragments instead of simple views.
 */
public class MainActivity extends FragmentActivity {
    TabHost mTabHost;
    TabManager mTabManager;

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

        setContentView(R.layout.activity_main);
        mTabHost = (TabHost)findViewById(android.R.id.tabhost);//Container for a tabbed window view.
        mTabHost.setup();

        mTabManager = new TabManager(this, mTabHost, R.id.realtabcontent);// tab host와 탭을 눌렀을때 바뀌어야하는 부분의 id
        mTabManager.addTab(mTabHost.newTabSpec("simple").setIndicator("Simple"), Fragment1.class, null);	//새로운 탭을 만든다.
        //tabspec -> A tab has a tab indicator, content, and a tag that is used to keep track of it
        mTabManager.addTab(mTabHost.newTabSpec("contacts").setIndicator("Contacts"), Fragment2.class, null);
        mTabManager.addTab(mTabHost.newTabSpec("custom").setIndicator("Custom"), Fragment3.class, null);


        if (savedInstanceState != null) {
            mTabHost.setCurrentTabByTag(savedInstanceState.getString("tab"));	// 방향 전환 전에 선택된 탭이 있다면 가져와서 설정
        }
    }

    @Override
    protected void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        outState.putString("tab", mTabHost.getCurrentTabTag());	// 방향 전환될때 넣어준다.
        Log.e("tab", mTabHost.getCurrentTabTag());
    }

    /**
     * This is a helper class that implements a generic mechanism for
     * associating fragments with the tabs in a tab host.  It relies on a
     * trick.  Normally a tab host has a simple API for supplying a View or
     * Intent that each tab will show.  This is not sufficient for switching
     * between fragments.  So instead we make the content part of the tab host
     * 0dp high (it is not shown) and the TabManager supplies its own dummy
     * view to show as the tab content.  It listens to changes in tabs, and takes
     * care of switch to the correct fragment shown in a separate content area
     * whenever the selected tab changes.
     */
    public static class TabManager implements TabHost.OnTabChangeListener {
        private final FragmentActivity mActivity;	//context
        private final TabHost mTabHost;
        private final int mContainerId;	
        private final HashMap mTabs = new HashMap();	// tag기준으로 tab에대한 정보가 들어있다.
        TabInfo mLastTab;

        static final class TabInfo {
            private final String tag;
            private final Class clss;
            private final Bundle args;
            private Fragment fragment;

            TabInfo(String _tag, Class _class, Bundle _args) {
                tag = _tag;
                clss = _class;
                args = _args;
            }
        }

        static class DummyTabFactory implements TabHost.TabContentFactory{ // Makes the content of a tab when it is selected. 
        	// 굳이 필요 없어 보이는 듯
            private final Context mContext;

            public DummyTabFactory(Context context) {
                mContext = context;
            }

            @Override
            public View createTabContent(String tag) {
                View v = new View(mContext);
                v.setMinimumWidth(0);
                v.setMinimumHeight(0);
                return v;
            }
        }

        public TabManager(FragmentActivity activity, TabHost tabHost, int containerId) {
            mActivity = activity;
            mTabHost = tabHost;
            mContainerId = containerId;
            mTabHost.setOnTabChangedListener(this);
        }

        public void addTab(TabHost.TabSpec tabSpec, Class clss, Bundle args) {	// tab추가하기
            tabSpec.setContent(new DummyTabFactory(mActivity));
            String tag = tabSpec.getTag();

            TabInfo info = new TabInfo(tag, clss, args);	// 그닥 필요없어 보이긴함

            // Check to see if we already have a fragment for this tab, probably
            // from a previously saved state.  If so, deactivate it, because our
            // initial state is that a tab isn't shown.
            info.fragment = mActivity.getSupportFragmentManager().findFragmentByTag(tag);	//tag로 프래그먼트 찾아서 넣어준다.
            if (info.fragment != null && !info.fragment.isDetached()) {	//frament가 null이아니고 떨어져있지 않으면 떼준다.
            	
                FragmentTransaction ft = mActivity.getSupportFragmentManager().beginTransaction();
                ft.detach(info.fragment);
                ft.commit();
            }

            mTabs.put(tag, info);	//자료형에 넣어준다. 이것도 불필요함
            mTabHost.addTab(tabSpec);	// 탭호스트에 실제로 탭을 넣어준다.
        }

        @Override
        public void onTabChanged(String tabId) {
            TabInfo newTab = mTabs.get(tabId);	// 넣어놨던 tabinfo찾아온다.
            if (mLastTab != newTab) {//라스트탭이 뉴탭과 같지 않다면
                FragmentTransaction ft = mActivity.getSupportFragmentManager().beginTransaction();
                if (mLastTab != null) {	//라스트탭이 널이 아니면
                    if (mLastTab.fragment != null) {	//라스트탭의 프래그먼트가 널이 아니면
                        ft.detach(mLastTab.fragment);	//떼어낸다
                    }
                }
                if (newTab != null) {	// 뉴탭이 널이 아니면
                    if (newTab.fragment == null) {	//프래그먼트가 널이면
                        newTab.fragment = Fragment.instantiate(mActivity,
                                newTab.clss.getName(), newTab.args);//새로 만들어준다
                        ft.add(mContainerId, newTab.fragment, newTab.tag);	//추가해준다
                    } else {
                        ft.attach(newTab.fragment);	//널이 아니면 그대로 붙여준다.
                    }
                }

                mLastTab = newTab;	//새로운탭이 라스트탭이 된다.
                ft.commit();
                mActivity.getSupportFragmentManager().executePendingTransactions();
            }
        }
    }
}

개인적인 생각으로 Fragment는 객체화시킬수 있는 서브 액티비티라는 생각이다. 

액티비티자체는 객체화 시킬수 없어 사용에 불편함이 있다. 

그러나 프래그먼트는 객체화가 가능하여 유연성있게 사용할 수 있다. 그리고 단독으로는 사용할 수 없다. 액티비티안에 사용할 수 있다.

액티비티 끼리는 인텐트를 주고받지만 프래그먼트는 argument로 값을 주고 받는다.

그런데 프래그먼트를 생성할때마다 Bundle을 만들어 아규먼트를 전달 받고 전달하는 것은 낭비라는 생각이 들어 메소드를 만든다.

static TextFragment newInstance(String _msg){
		TextFragment tf = new TextFragment();
		Bundle bundle = new Bundle();
		bundle.putString("msg", _msg);
		tf.setArguments(bundle);

		return tf;
	}

	public String getMsg(){
		if(getArguments().getString("msg")!=null){
			return getArguments().getString("msg");
		}
		return "msg";
	}

이런 식으로 메소드를 만들고 실제로 Fragment 객체를 생성할때는 new가 아닌

TextFragment tf = TextFragment.newInstance(((TextView)v).getText().toString());

이런 식으로 메소드를 호출하여 사용한다.

new로 생성하는 것외에 Fragment 에서 자체적으로 지원해주는 메소드도 있다. new로 생성하는 것과 차이는 없지만

인스턴스화가 실패했을 경우 에러 처리를 해준다.