Android
टुकड़े टुकड़े

परिचय

वाक्य - विन्यास

• void onActivityCreated (बंडल सेवइन्स्टांसस्टैट) // तब कॉल किया जाता है जब टुकड़ा की गतिविधि बनाई गई है और इस टुकड़े का दृश्य पदानुक्रम को त्वरित करता है।

• void onActivityResult (int requestCode, int resultCode, Intent data) // पिछले कॉल से परिणाम प्राप्त करें startActivityForResult (इरादे, इंट)।

• void onAttach (गतिविधि गतिविधि) // इस विधि को API स्तर 23 में पदावनत किया गया था। इसके बजाय onAachach (संदर्भ) का उपयोग करें।

• void onAttach (प्रसंग प्रसंग) // जब किसी खंड को पहली बार उसके संदर्भ से जोड़ा जाता है, तो उसे कॉल किया जाता है।

• void onAttachFragment (फ्रैग्मेंट चाइल्डग्रैगमेंट) // जिसे तब कहा जाता है जब एक टुकड़ा इस टुकड़े के बच्चे के रूप में जुड़ा होता है।

• void onConfigurationChanged (कॉन्फ़िगरेशन newConfig) // सिस्टम द्वारा तब कॉल किया जाता है जब आपका घटक चालू होने पर डिवाइस कॉन्फ़िगरेशन बदलता है।

• void onCreate (बंडल सहेजा गया। InstanceState) // एक टुकड़े का प्रारंभिक निर्माण करने के लिए कहा जाता है।

• OnCreateView (लेआउटइन्फ्लैटर इनफ्लोरर, व्यूग्रुप कंटेनर, बंडल सेवइन्स्टैंस्टस्टेट) देखें। // टुकड़े को उसके यूजर इंटरफेस व्यू को देखने के लिए कहा जाता है।

• void onDestroy () // तब कॉल किया जाता है जब टुकड़ा अब उपयोग में नहीं है।

• void onDestroyView () // कॉल किया गया जब व्यू को पहले onCreateView (LayoutInflater, ViewGroup, बंडल) द्वारा बनाया गया था, टुकड़े से अलग कर दिया गया है।

• void onDetach () // तब कॉल किया जाता है जब टुकड़ा अब उसकी गतिविधि से जुड़ा नहीं होता है।

• void onInflate (गतिविधि गतिविधि, AttributeSet attrs, बंडल सहेजी गई InstanceState) // इस विधि को API स्तर 23 में पदावनत किया गया था। इसके बजाय OnInflate (Context, AttributeSet, बंडल) का उपयोग करें।

• void onInflate (संदर्भ, गुण संदर्भ, बंडल सहेजे गए InstanceState) // जब एक खंड को व्यू लेआउट मुद्रास्फीति के हिस्से के रूप में बनाया जा रहा है, तो आमतौर पर किसी गतिविधि के सामग्री दृश्य को सेट करने से कहा जाता है।

• शून्य चालू () // जब खंडित नहीं रह जाता है तब कॉल किया जाता है।

• void onResume () // जब उपयोगकर्ता को टुकड़ा दिखाई दे रहा है और सक्रिय रूप से चल रहा है, तब कॉल किया गया।

• void onSaveInstanceState (बंडल आउटस्टैट) // को इसकी वर्तमान गतिशील स्थिति को बचाने के लिए टुकड़े को पूछने के लिए कहा जाता है, इसलिए इसे बाद में इसकी प्रक्रिया के एक नए उदाहरण में फिर से संगठित किया जा सकता है।

• void onStart () // जब उपयोगकर्ता को फ्रैगमेंट दिखाई देता है, तब कॉल किया जाता है।

• शून्य onStop () // जिसे तब प्रारंभ किया जाता है जब फ्रेगमेंट प्रारंभ नहीं होता है।

• void onViewStateRestored (बंडल सहेजा गया InstanceState) // जब सभी सहेजे गए राज्य को खंड के दृश्य पदानुक्रम में पुनर्स्थापित किया गया हो।

टिप्पणियों

NewInstance () पैटर्न

हालाँकि, मापदंडों के साथ एक टुकड़ा निर्माणकर्ता बनाना संभव है, एंड्रॉइड आंतरिक रूप से शून्य-तर्क वाले निर्माता को कॉल करता है जब टुकड़ों को फिर से बनाया जाता है (उदाहरण के लिए, अगर उन्हें एंड्रॉइड के अपने कारणों से मारे जाने के बाद बहाल किया जा रहा है)। इस कारण से, ऐसे निर्माता पर भरोसा करना उचित नहीं है जिसके पास पैरामीटर हैं।

यह सुनिश्चित करने के लिए कि आपके अपेक्षित खंड तर्क हमेशा मौजूद हैं, आप एक newInstance() बनाने के लिए स्थैतिक newInstance() विधि का उपयोग कर सकते हैं, और एक बंडल में जो भी पैरामीटर आप चाहते हैं उसे डाल सकते हैं जो एक नया उदाहरण बनाते समय उपलब्ध होगा।

import android.os.Bundle;
import android.support.v4.app.Fragment;

public class MyFragment extends Fragment
{
  // Our identifier for obtaining the name from arguments
  private static final String NAME_ARG = "name";

  private String mName;

  // Required
  public MyFragment(){}

  // The static constructor.  This is the only way that you should instantiate
  // the fragment yourself
  public static MyFragment newInstance(final String name) {
    final MyFragment myFragment = new MyFragment();
    // The 1 below is an optimization, being the number of arguments that will
    // be added to this bundle.  If you know the number of arguments you will add
    // to the bundle it stops additional allocations of the backing map.  If
    // unsure, you can construct Bundle without any arguments
    final Bundle args = new Bundle(1);

    // This stores the argument as an argument in the bundle.  Note that even if
    // the 'name' parameter is NULL then this will work, so you should consider
    // at this point if the parameter is mandatory and if so check for NULL and
    // throw an appropriate error if so
    args.putString(NAME_ARG, name);

    myFragment.setArguments(args);
    return myFragment;
  }

  @Override
  public void onCreate(final Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    final Bundle arguments = getArguments();
    if (arguments == null || !arguments.containsKey(NAME_ARG)) {
      // Set a default or error as you see fit
    } else {
      mName = arguments.getString(NAME_ARG);
    }
  }
}

अब, गतिविधि में:

FragmentTransaction ft = getSupportFragmentManager().beginTransaction();
MyFragment mFragment = MyFragment.newInstance("my name");
ft.replace(R.id.placeholder, mFragment);
//R.id.placeholder is where we want to load our fragment
ft.commit();

यह पैटर्न यह सुनिश्चित करने के लिए एक सर्वोत्तम अभ्यास है कि सभी आवश्यक तर्क सृजन पर टुकड़े करने के लिए पारित किए जाएंगे। ध्यान दें कि जब सिस्टम खंड को नष्ट कर देता है और बाद में इसे फिर से बनाता है, तो यह स्वचालित रूप से अपनी स्थिति को बहाल करेगा - लेकिन आपको इसे onSaveInstanceState(Bundle) कार्यान्वयन के साथ प्रदान करना होगा।

बैकस्टैक और स्थिर कपड़े पैटर्न का उपयोग करके टुकड़ों के बीच नेविगेशन

सबसे पहले, हमें शुरुआत में अपना पहला Fragment जोड़ना होगा, हमें इसे अपनी गतिविधि के onCreate() विधि में करना चाहिए:

if (null == savedInstanceState) {
    getSupportFragmentManager().beginTransaction()
      .addToBackStack("fragmentA")
      .replace(R.id.container, FragmentA.newInstance(), "fragmentA")
      .commit();
}

अगला, हमें अपने बैकस्टैक को प्रबंधित करने की आवश्यकता है। सबसे आसान तरीका हमारी गतिविधि में जोड़े गए फ़ंक्शन का उपयोग करना है जो सभी FragmentTransactions के लिए उपयोग किया जाता है।

public void replaceFragment(Fragment fragment, String tag) {
    //Get current fragment placed in container
    Fragment currentFragment = getSupportFragmentManager().findFragmentById(R.id.container);

    //Prevent adding same fragment on top
    if (currentFragment.getClass() == fragment.getClass()) {
        return;
    }

    //If fragment is already on stack, we can pop back stack to prevent stack infinite growth
    if (getSupportFragmentManager().findFragmentByTag(tag) != null) {
        getSupportFragmentManager().popBackStack(tag, FragmentManager.POP_BACK_STACK_INCLUSIVE);
    }

    //Otherwise, just replace fragment
    getSupportFragmentManager()
            .beginTransaction()
            .addToBackStack(tag)
            .replace(R.id.container, fragment, tag)
            .commit();
}

अंत में, बैकस्ट में उपलब्ध अंतिम खंड से वापस जाने पर हमें एप्लिकेशन से बाहर निकलने के लिए onBackPressed() को ओवरराइड करना चाहिए।

@Override
public void onBackPressed() {
    int fragmentsInStack = getSupportFragmentManager().getBackStackEntryCount();
    if (fragmentsInStack > 1) { // If we have more than one fragment, pop back stack
        getSupportFragmentManager().popBackStack();
    } else if (fragmentsInStack == 1) { // Finish activity, if only one fragment left, to prevent leaving empty screen
        finish();
    } else {
        super.onBackPressed();
    }
}

गतिविधि में निष्पादन:

replaceFragment(FragmentB.newInstance(), "fragmentB");

बाहर की गतिविधि ( MainActivity हमारी गतिविधि है, यह मानते हुए):

((MainActivity) getActivity()).replaceFragment(FragmentB.newInstance(), "fragmentB");

बंडल का उपयोग करके गतिविधि से फ्रैगमेंट तक डेटा पास करें

सभी टुकड़ों में एक खाली कंस्ट्रक्टर होना चाहिए (यानी एक कंस्ट्रक्टर विधि जिसमें कोई इनपुट तर्क नहीं हैं)। इसलिए, आपके डेटा को बनाए जा रहे Fragment में पास करने के लिए, आपको setArguments() विधि का उपयोग करना चाहिए। इस विधियों में एक बंडल मिलता है, जिसे आप अपने डेटा को स्टोर करते हैं, और बंडल को तर्कों में संग्रहीत करते हैं। इसके बाद, इस बंडल को फिर onCreate() और onCreateView() कॉल बैक ऑफ द फ्रैगमेंट में प्राप्त किया जा सकता है।

गतिविधि:

 Bundle bundle = new Bundle();
 String myMessage = "Stack Overflow is cool!";
 bundle.putString("message", myMessage );
 FragmentClass fragInfo = new FragmentClass();
 fragInfo.setArguments(bundle);
 transaction.replace(R.id.fragment_single, fragInfo);
 transaction.commit();

टुकड़ा:

 @Override
 public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
    String myValue = this.getArguments().getString("message");
    ...
 }

कॉलबैक इंटरफ़ेस के साथ एक गतिविधि पर वापस घटनाओं को भेजना

अगर आपको घटनाओं को खंड से गतिविधि तक भेजने की आवश्यकता है, तो संभव समाधानों में से एक कॉलबैक इंटरफ़ेस को परिभाषित करना है और इसके लिए आवश्यक है कि मेजबान गतिविधि इसे लागू करें।

उदाहरण

एक गतिविधि पर कॉलबैक भेजें, जब टुकड़े का बटन क्लिक किया गया

public interface SampleCallback {
    void onButtonClicked();
}

अगला कदम टुकड़े में इस कॉलबैक को निर्दिष्ट करना है:

public final class SampleFragment extends Fragment {

    private SampleCallback callback;

    @Override
    public void onAttach(Context context) {
        super.onAttach(context);
        if (context instanceof SampleCallback) {
            callback = (SampleCallback) context;
        } else {
            throw new RuntimeException(context.toString()
                    + " must implement SampleCallback");
        }
    }

    @Override
    public void onDetach() {
        super.onDetach();
        callback = null;
    }

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        final View view = inflater.inflate(R.layout.sample, container, false);
        // Add button's click listener
        view.findViewById(R.id.actionButton).setOnClickListener(new View.OnClickListener() {
            public void onClick(View v) {
                callback.onButtonClicked(); // Invoke callback here
            }
        });
        return view;
    }
}

और अंत में, गतिविधि में कॉलबैक लागू करें:

public final class SampleActivity extends Activity implements SampleCallback {

    // ... Skipped code with settings content view and presenting the fragment

    @Override
    public void onButtonClicked() {
        // Invoked when fragment's button has been clicked
    }
}

टुकड़ों के बीच संक्रमण चेतन

टुकड़ों के बीच संक्रमण को चेतन करने के लिए, या एक टुकड़े को दिखाने या छिपाने की प्रक्रिया को चेतन करने के लिए आप एक FragmentTransaction बनाने के लिए FragmentManager का उपयोग करते हैं।

एक एकल FragmentTransaction , एनिमेशन करने के दो अलग-अलग तरीके हैं: आप एक मानक एनीमेशन का उपयोग कर सकते हैं या आप अपने स्वयं के कस्टम एनिमेशन की आपूर्ति कर सकते हैं।

मानक एनिमेशन FragmentTransaction.setTransition(int transit) को कॉल करके, और FragmentTransaction वर्ग में उपलब्ध पूर्व-परिभाषित स्थिरांक में से एक का उपयोग करके निर्दिष्ट किया जाता है। लेखन के समय, ये स्थिरांक हैं:

FragmentTransaction.TRANSIT_NONE
FragmentTransaction.TRANSIT_FRAGMENT_OPEN
FragmentTransaction.TRANSIT_FRAGMENT_CLOSE
FragmentTransaction.TRANSIT_FRAGMENT_FADE

पूरा लेनदेन कुछ इस तरह दिखाई दे सकता है:

getSupportFragmentManager()
    .beginTransaction()
    .setTransition(FragmentTransaction.TRANSIT_FRAGMENT_FADE)
    .replace(R.id.contents, new MyFragment(), "MyFragmentTag")
    .commit();

कस्टम एनिमेशन या तो FragmentTransaction.setCustomAnimations(int enter, int exit) या FragmentTransaction.setCustomAnimations(int enter, int exit, int popEnter, int popExit) ।

enter और exit एनिमेशन FragmentTransaction s के लिए खेले जाएंगे, जिसमें बैक स्टैक के पॉपिंग टुकड़े शामिल नहीं हैं। बैक स्टैक के एक टुकड़े को पॉप करने पर popEnter और popExit एनिमेशन खेला जाएगा।

निम्न कोड दिखाता है कि आप एक टुकड़े को कैसे हटाकर एक टुकड़े को बदल देंगे और दूसरे को उसके स्थान पर खिसका देंगे।

getSupportFragmentManager()
    .beginTransaction()
    .setCustomAnimations(R.anim.slide_in_left, R.anim.slide_out_right)
    .replace(R.id.contents, new MyFragment(), "MyFragmentTag")
    .commit();

XML एनीमेशन परिभाषाएँ objectAnimator टैग का उपयोग करेगी। Slide_in_left.xml का एक उदाहरण कुछ इस तरह दिखाई दे सकता है:

<?xml version="1.0" encoding="utf-8"?>
<set>
  <objectAnimator xmlns:android="http://schemas.android.com/apk/res/android"
    android:propertyName="x" 
    android:valueType="floatType"
    android:valueFrom="-1280"
    android:valueTo="0" 
    android:duration="500"/>
</set>

टुकड़े के बीच संचार

टुकड़े के बीच सभी संचार एक गतिविधि के माध्यम से जाना चाहिए। टुकड़े एक गतिविधि के बिना एक दूसरे के साथ संवाद नहीं कर सकते ।

अतिरिक्त संसाधन

• OnFragmentInteractionListener को कैसे लागू करें
• Android | अन्य टुकड़े के साथ संचार

इस नमूने में, हमारे पास एक MainActivity जो दो message , SenderFragment और ReceiverFragment क्रमशः एक message भेजने और प्राप्त करने (इस मामले में एक साधारण स्ट्रिंग) के लिए होस्ट करता है।

SenderFragment में एक बटन संदेश भेजने की प्रक्रिया शुरू करता है। संदेश प्राप्त होने पर ReceiverFragment में एक TextView अपडेट किया जाता है।

कोड की महत्वपूर्ण पंक्तियों की व्याख्या करने वाली टिप्पणियों के साथ MainActivity के लिए स्निपेट निम्नलिखित है:

// Our MainActivity implements the interface defined by the SenderFragment. This enables
// communication from the fragment to the activity
public class MainActivity extends AppCompatActivity implements SenderFragment.SendMessageListener {

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
}

/**
 * This method is called when we click on the button in the SenderFragment
 * @param message The message sent by the SenderFragment
 */
@Override
public void onSendMessage(String message) {
    // Find our ReceiverFragment using the SupportFragmentManager and the fragment's id
    ReceiverFragment receiverFragment = (ReceiverFragment)
            getSupportFragmentManager().findFragmentById(R.id.fragment_receiver);

    // Make sure that such a fragment exists
    if (receiverFragment != null) {
        // Send this message to the ReceiverFragment by calling its public method
        receiverFragment.showMessage(message);
    }
}
}

MainActivity लिए लेआउट फ़ाइल LinearLayout के अंदर दो अंशों को होस्ट करती है:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/activity_main"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:paddingBottom="@dimen/activity_vertical_margin"
    android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin"
    tools:context="com.naru.fragmentcommunication.MainActivity">

<fragment
    android:id="@+id/fragment_sender"
    android:name="com.naru.fragmentcommunication.SenderFragment"
    android:layout_width="match_parent"
    android:layout_height="0dp"
    android:layout_weight="1"
    tools:layout="@layout/fragment_sender" />

<fragment
    android:id="@+id/fragment_receiver"
    android:name="com.naru.fragmentcommunication.ReceiverFragment"
    android:layout_width="match_parent"
    android:layout_height="0dp"
    android:layout_weight="1"
    tools:layout="@layout/fragment_receiver" />
</LinearLayout>

SenderFragment एक अंतरफलक को उजागर करता है SendMessageListener मदद करता है कि MainActivity पता जब में बटन SenderFragment क्लिक किया गया था।

निम्नलिखित कोड की महत्वपूर्ण पंक्तियों को बताते हुए SenderFragment लिए कोड स्निपेट है:

public class SenderFragment extends Fragment {

private SendMessageListener commander;

/**
 * This interface is created to communicate between the activity and the fragment. Any activity
 * which implements this interface will be able to receive the message that is sent by this
 * fragment.
 */
public interface SendMessageListener {
    void onSendMessage(String message);
}

/**
 * API LEVEL >= 23
 * <p>
 * This method is called when the fragment is attached to the activity. This method here will
 * help us to initialize our reference variable, 'commander' , for our interface
 * 'SendMessageListener'
 *
 * @param context
 */
@Override
public void onAttach(Context context) {
    super.onAttach(context);
    // Try to cast the context to our interface SendMessageListener i.e. check whether the
    // activity implements the SendMessageListener. If not a ClassCastException is thrown.
    try {
        commander = (SendMessageListener) context;
    } catch (ClassCastException e) {
        throw new ClassCastException(context.toString()
                + "must implement the SendMessageListener interface");
    }
}

/**
 * API LEVEL < 23
 * <p>
 * This method is called when the fragment is attached to the activity. This method here will
 * help us to initialize our reference variable, 'commander' , for our interface
 * 'SendMessageListener'
 *
 * @param activity
 */
@Override
public void onAttach(Activity activity) {
    super.onAttach(activity);
    // Try to cast the context to our interface SendMessageListener i.e. check whether the
    // activity implements the SendMessageListener. If not a ClassCastException is thrown.
    try {
        commander = (SendMessageListener) activity;
    } catch (ClassCastException e) {
        throw new ClassCastException(activity.toString()
                + "must implement the SendMessageListener interface");
    }
}

@Nullable
@Override
public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container,
                         @Nullable Bundle savedInstanceState) {
    // Inflate view for the sender fragment.
    View view = inflater.inflate(R.layout.fragment_receiver, container, false);

    // Initialize button and a click listener on it
    Button send = (Button) view.findViewById(R.id.bSend);
    send.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {

            // Sanity check whether we were able to properly initialize our interface reference
            if (commander != null) {

                // Call our interface method. This enables us to call the implemented method
                // in the activity, from where we can send the message to the ReceiverFragment.
                commander.onSendMessage("HELLO FROM SENDER FRAGMENT!");
            }
        }
    });

    return view;
}
}

SenderFragment लिए लेआउट फ़ाइल:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:gravity="center"
    android:orientation="vertical">

<Button
    android:id="@+id/bSend"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="SEND"
    android:layout_gravity="center_horizontal" />
</LinearLayout>

ReceiverFragment सरल है और अपने TextView को अद्यतन करने के लिए एक सरल सार्वजनिक विधि को उजागर करता है। जब MainActivity से संदेश प्राप्त करता है, SenderFragment यह ReceiverFragment की इस सार्वजनिक विधि को कॉल करता है

कोड की महत्वपूर्ण पंक्तियों की व्याख्या करने वाली टिप्पणियों के साथ ReceiverFragment लिए कोड स्निपेट निम्नलिखित है:

public class ReceiverFragment extends Fragment {
TextView tvMessage;

@Nullable
@Override
public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container,
                         @Nullable Bundle savedInstanceState) {
    // Inflate view for the sender fragment.
    View view = inflater.inflate(R.layout.fragment_receiver, container, false);

    // Initialize the TextView
    tvMessage = (TextView) view.findViewById(R.id.tvReceivedMessage);

    return view;
}


/**
 * Method that is called by the MainActivity when it receives a message from the SenderFragment.
 * This method helps update the text in the TextView to the message sent by the SenderFragment.
 * @param message Message sent by the SenderFragment via the MainActivity.
 */
public void showMessage(String message) {
    tvMessage.setText(message);
}
}

ReceiverFragment लिए लेआउट फ़ाइल:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:gravity="center"
    android:orientation="vertical">
<TextView
    android:id="@+id/tvReceivedMessage"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="Waiting for message!" />
</LinearLayout>