Invia dati dall'attività al frammento in Android

Ho due lezioni. Il primo è l'attività, il secondo è un frammento in cui ne ho alcuni EditText. Nell'attività ho una sottoclasse con async-task e nel metodo doInBackgroundottengo un risultato, che salvo nella variabile. Come posso inviare questa variabile dalla sottoclasse "la mia attività" a questo frammento?

Dall'attività si inviano i dati con l'intento di:

Bundle bundle = new Bundle();
bundle.putString("edttext", "From Activity");
// set Fragmentclass Arguments
Fragmentclass fragobj = new Fragmentclass();
fragobj.setArguments(bundle);

e nel metodo Fragment onCreateView:

@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
        Bundle savedInstanceState) {
    String strtext = getArguments().getString("edttext");    
    return inflater.inflate(R.layout.fragment, container, false);
}

Inoltre è possibile accedere ai dati delle attività dal frammento:

Attività:

public class MyActivity extends Activity {

    private String myString = "hello";

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

    public String getMyData() {
        return myString;
    }
}

Frammento:

public class MyFragment extends Fragment {

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {

        MyActivity activity = (MyActivity) getActivity();
        String myDataFromActivity = activity.getMyData();
        return view;
    }
}

Ho trovato molte risposte qui @ stackoverflow.com ma sicuramente questa è la risposta corretta di:

"Invio di dati dall'attività al frammento in Android".

Attività:

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

Frammento:

Lettura del valore nel frammento

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

o solo

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

Questa risposta potrebbe essere troppo tardi. ma sarà utile per i futuri lettori.

Ho dei criteri. Ho codificato per scegliere il file dall'intento. e il file selezionato da passare a un frammento particolare per un ulteriore processo. ho molti frammenti che hanno la funzionalità di raccolta file. al momento, ogni volta controllare la condizione e ottenere il frammento e passare il valore è abbastanza disgustoso. così, ho deciso di passare il valore utilizzando l'interfaccia.

Passaggio 1: creare l'interfaccia sull'attività principale.

   public interface SelectedBundle {
    void onBundleSelect(Bundle bundle);
   }

Passaggio 2: creare il riferimento SelectedBundle sulla stessa attività

   SelectedBundle selectedBundle;

Passaggio 3: creare il metodo nella stessa attività

   public void setOnBundleSelected(SelectedBundle selectedBundle) {
       this.selectedBundle = selectedBundle;
   }

Passaggio 4: è necessario inizializzare il riferimento SelectedBundle che sono tutti frammenti che richiedono la funzionalità filepicker. Posizionare questo codice sul onCreateView(..)metodo del frammento

    ((MainActivity)getActivity()).setOnBundleSelected(new MainActivity.SelectedBundle() {
          @Override
         public void onBundleSelect(Bundle bundle) {
            updateList(bundle);
        }
     });

Passaggio 5: il mio caso, devo passare l'immagine Uri da HomeActivity al frammento. Quindi, ho usato questa funzionalità sul metodo onActivityResult.

onActivityRisultato da MainActivity, passare i valori ai frammenti utilizzando l'interfaccia.

Nota: il tuo caso potrebbe essere diverso. puoi chiamarlo da qualsiasi luogo dalla tua HomeActivity.

 @Override
 protected void onActivityResult(int requestCode, int resultCode, Intent  data) {
       selectedBundle.onBundleSelect(bundle);
  }

È tutto. Implementa ogni frammento necessario su FragmentClass. Sei grande. hai fatto. WOW...

L'idea di base dell'utilizzo di Fragments (F) è quella di creare componenti dell'interfaccia utente autosufficienti riutilizzabili nelle applicazioni Android. Questi frammenti sono contenuti nelle attività e ci sono modi comuni (migliori) per creare percorsi di comunicazione da A -> F e FA, è un must comunicare tra FF attraverso un'attività perché solo i frammenti diventano disaccoppiati e autosufficienti.

Quindi il passaggio di dati da A -> F sarà lo stesso spiegato da ρяσѕρєя K. Oltre a quella risposta, Dopo la creazione dei frammenti all'interno di un'attività, possiamo anche passare i dati ai frammenti chiamando metodi in Fragments.

Per esempio:

    ArticleFragment articleFrag = (ArticleFragment)
                    getSupportFragmentManager().findFragmentById(R.id.article_fragment);
    articleFrag.updateArticleView(position);

L'approccio migliore e conveniente è chiamare l'istanza del frammento e inviare i dati in quel momento. ogni frammento di default ha un metodo di istanza

Ad esempio: se il nome del tuo frammento è MyFragment

così chiamerai il tuo frammento da attività come questa:

getSupportFragmentManager().beginTransaction().add(R.id.container, MyFragment.newInstance("data1","data2"),"MyFragment").commit();

* R.id.container è un ID del mio FrameLayout

quindi in MyFragment.newInstance ("data1", "data2") puoi inviare dati al frammento e nel tuo frammento ottieni questi dati in MyFragment newInstance (String param1, String param2)

public static MyFragment newInstance(String param1, String param2) {
        MyFragment fragment = new MyFragment();
        Bundle args = new Bundle();
        args.putString(ARG_PARAM1, param1);
        args.putString(ARG_PARAM2, param2);
        fragment.setArguments(args);
        return fragment;
    }

e poi nel metodo onCreate di frammento otterrai i dati:

@Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        if (getArguments() != null) {
            mParam1 = getArguments().getString(ARG_PARAM1);
            mParam2 = getArguments().getString(ARG_PARAM2);
        }
    }

così ora mParam1 ha data1 e mParam2 ha data2

ora puoi usare questo mParam1 e mParam2 nel tuo frammento.

Vorrei aggiungere per i principianti che la differenza tra le 2 risposte più votate qui è data dal diverso uso di un frammento.

Se usi il frammento all'interno della classe java in cui hai i dati che vuoi passare, puoi applicare la prima risposta per passare i dati:

Bundle bundle = new Bundle();
bundle.putString("edttext", "From Activity");
Fragmentclass fragobj = new Fragmentclass();
fragobj.setArguments(bundle);

Se tuttavia utilizzi ad esempio il codice predefinito fornito da Android Studio per i frammenti a schede, questo codice non funzionerà.

Non funzionerà anche se si sostituisce PlaceholderFragment predefinito con FragmentClasses e anche se si corregge FragmentPagerAdapter alla nuova situazione aggiungendo un'opzione per getItem () e un'altra opzione per getPageTitle () (come mostrato qui )

Attenzione: la clip sopra menzionata contiene errori di codice, che spiegherò più avanti qui, ma è utile per vedere come si passa dal codice predefinito al codice modificabile per i frammenti a schede)! Il resto della mia risposta ha molto più senso se si considerano le classi Java e i file XML da quella clip (rappresentativi per un primo utilizzo di frammenti a schede da uno scenario per principianti).

Il motivo principale per cui la risposta più votata da questa pagina non funzionerà è che in quel codice predefinito per i frammenti a schede, i frammenti vengono utilizzati in un'altra classe Java: FragmentPagerAdapter!

Quindi, per inviare i dati, sei tentato di creare un pacchetto in MotherActivity e passarlo in FragmentPagerAdapter, usando la risposta n. 2.

Solo quello è di nuovo sbagliato. ( Probabilmente potresti farlo in quel modo, ma è solo una complicazione che non è davvero necessaria ).

Il modo corretto / più semplice per farlo, penso, è di passare i dati direttamente al frammento in questione, usando la risposta n. 2. Sì, ci sarà uno stretto accoppiamento tra l'attività e il frammento, MA, per i frammenti a schede, è un po 'previsto. Ti consiglierei anche di creare i frammenti a schede all'interno della classe java MotherActivity (come sottoclassi, in quanto non verranno mai utilizzati al di fuori di MotherActivity) - è facile, basta aggiungere all'interno della classe java MotherActivity tutti i frammenti di cui hai bisogno in questo modo:

 public static class Tab1 extends Fragment {

    public Tab1() {
    }

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
                             Bundle savedInstanceState) {
        View rootView = inflater.inflate(R.layout.your_layout_name_for_fragment_1, container, false);
        return rootView;
    }
}.

Quindi, per trasferire i dati da MotherActivity a un tale frammento, dovrai creare stringhe / bundle privati ​​sopra l'onCreate della tua attività madre - che puoi riempire con i dati che vuoi passare ai frammenti e trasmetterli tramite un metodo creato dopo onCreate (qui chiamato getMyData ()).

public class MotherActivity extends Activity {

    private String out;
    private Bundle results;

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

       // for example get a value from the previous activity
        Intent intent = getIntent();
        out = intent.getExtras().getString("Key");

    }

    public Bundle getMyData() {
        Bundle hm = new Bundle();
        hm.putString("val1",out);
        return hm;
    }
}

E poi nella classe dei frammenti, usi getMyData:

public static class Tab1 extends Fragment {
        /**
         * The fragment argument representing the section number for this
         * fragment.
         */
        public Tab1() {
        }

        @Override
        public View onCreateView(LayoutInflater inflater, ViewGroup container,
                                 Bundle savedInstanceState) {
            View rootView = inflater.inflate(R.layout.your_layout_name_for_fragment_1, container, false);
            TextView output = (TextView)rootView.findViewById(R.id.your_id_for_a_text_view_within_the_layout);

            MotherActivity activity = (MotherActivity)getActivity();

            Bundle results = activity.getMyData();
            String value1 = results.getString("val1");

            output.setText(value1);
            return rootView;
        }
    }

Se hai domande sul database ti consiglio di eseguirle in MotherActivity (e passare i loro risultati come stringhe / numeri interi collegati alle chiavi all'interno di un bundle come mostrato sopra), come all'interno dei frammenti a schede, la tua sintassi diventerà più complessa (questo diventa getActivity () ad esempio, e getIntent diventa getActivity (). getIntent), ma hai anche la possibilità di fare ciò che desideri.

Il mio consiglio per i principianti è di concentrarsi su piccoli passi. Innanzitutto, cerca di aprire un'attività a schede molto semplice, senza passare QUALSIASI dato. Funziona? Apre le schede che ti aspetti? Se no, perché?

Inizia da quello e applicando soluzioni come quelle presentate in questa clip , vedi cosa manca. Per quel particolare clip, mainactivity.xml non viene mai mostrato. Questo sicuramente ti confonderà. Ma se presti attenzione, vedrai che ad esempio il contesto (strumenti: contesto) è errato nei file di frammenti XML. Ogni frammento XML deve puntare alla classe di frammento corretta (o sottoclasse usando il separatore $).

Vedrai anche che nella principale attività java class devi aggiungere tabLayout.setupWithViewPager (mViewPager) - subito dopo la riga TabLayout tabLayout = (TabLayout) findViewById (R.id.tabs); senza questa linea, la tua vista non è in realtà collegata ai file XML dei frammenti, ma mostra SOLO il file xml dell'attività principale.

Oltre alla riga nella classe java dell'attività principale, nel file XML dell'attività principale è necessario modificare le schede per adattarle alla propria situazione (ad esempio aggiungere o rimuovere TabItems). Se non hai schede nell'XML dell'attività principale, probabilmente non hai scelto il tipo di attività corretto quando lo hai creato in primo luogo (nuova attività - attività a schede).

Si noti che negli ultimi 3 paragrafi parlo del video! Quindi, quando dico XML dell'attività principale, è il XML dell'attività principale nel video, che nella tua situazione è il file XML di MotherActivity.

Se si passa un riferimento al frammento (sottoclasse concreta di) nell'attività asincrona, è possibile accedere direttamente al frammento.

Alcuni modi per passare il riferimento al frammento nell'attività asincrona:

• Se l'attività asincrona è una classe a tutti gli effetti ( class FooTask extends AsyncTask), passa il tuo frammento al costruttore.
• Se l'attività asincrona è una classe interna, è sufficiente dichiarare una variabile di frammento finale nell'ambito definito dall'attività asincrona o come campo della classe esterna. Potrai accedervi dalla classe interna.

A volte puoi ricevere Intento nella tua attività e devi passare le informazioni al tuo frammento di lavoro.
Le risposte fornite sono OK se è necessario avviare il frammento ma se funziona ancora, setArguments()non è molto utile.
Un altro problema si verifica se le informazioni passate causeranno l'interazione con l'interfaccia utente. In tal caso non puoi chiamare qualcosa del genere myfragment.passData()perché Android dirà rapidamente che solo il thread che ha creato la vista può interagire.

Quindi la mia proposta è di usare un ricevitore. In questo modo, è possibile inviare dati da qualsiasi luogo, compresa l'attività, ma il lavoro verrà eseguito nel contesto del frammento.

Nel tuo frammento onCreate():

protected DataReceiver dataReceiver;
public static final String REC_DATA = "REC_DATA";

@Override
public void onCreate(Bundle savedInstanceState) {


    data Receiver = new DataReceiver();
    intentFilter = new IntentFilter(REC_DATA);

    getActivity().registerReceiver(dataReceiver, intentFilter);
}

private class DataReceiver extends BroadcastReceiver {

    @Override
    public void onReceive(Context context, Intent intent) {

        int data= intent.getIntExtra("data", -1);

        // Do anything including interact with your UI
    }
}

Nella tua attività:

// somewhere
Intent retIntent = new Intent(RE_DATA);
retIntent.putExtra("data", myData);
sendBroadcast(retIntent);

Post molto vecchio, ho ancora il coraggio di aggiungere una piccola spiegazione che mi sarebbe stata utile.

Tecnicamente puoi impostare direttamente membri di qualsiasi tipo in un frammento dall'attività.
Allora perché Bundle?
Il motivo è molto semplice: il bundle fornisce un modo uniforme di gestire:
- la creazione / apertura di frammenti
- la riconfigurazione (rotazione dello schermo) - basta aggiungere il bundle iniziale / aggiornato a outState in onSaveInstanceState ()
- il ripristino delle app dopo essere stato raccolto in background ( come con la riconfigurazione).

Puoi (se ti piacciono gli esperimenti) creare una soluzione alternativa in situazioni semplici, ma l'approccio in bundle non vede la differenza tra un frammento e mille su uno backstack: rimane semplice e diretto.
Ecco perché la risposta di @Elenasys è la soluzione più elegante e universale.
Ed è per questo che la risposta data da @Martin ha delle insidie

l'approccio migliore per l'invio di dati dalla classe di attività al frammento sta passando attraverso i metodi setter. Piace

FragmentClass fragmentClass = new FragmentClass();
fragmentClass.setMyList(mylist);
fragmentClass.setMyString(myString);
fragmentClass.setMyMap(myMap);

e ottenere facilmente questi dati dalla classe.

Da Activityte invii i dati con Bundle come:

Bundle bundle = new Bundle();
bundle.putString("data", "Data you want to send");

// Your fragment
MyFragment obj = new MyFragment();
obj.setArguments(bundle);

E nel Fragmentmetodo onCreateView ottieni i dati:

@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) 
{
    String data = getArguments().getString("data");// data which sent from activity  
    return inflater.inflate(R.layout.myfragment, container, false);
}

Se è activitynecessario fragmenteseguire un'azione dopo l'inizializzazione, il modo più semplice consiste nel activityrichiamare un metodo fragmentsull'istanza. Nel fragment, aggiungi un metodo:

public class DemoFragment extends Fragment {
  public void doSomething(String param) {
      // do something in fragment
  }
}

e poi in activity, accedi afragment usando il fragmentgestore e chiama method:

public class MainActivity extends FragmentActivity {
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        DemoFragment fragmentDemo = (DemoFragment) 
            getSupportFragmentManager().findFragmentById(R.id.fragmentDemo);
        fragmentDemo.doSomething("some param");
    }
}

e quindi il activitypuò comunicare direttamente con il fragmentinvocando questo method.

Utilizzare la seguente interfaccia per comunicare tra attività e frammento

public interface BundleListener {
    void update(Bundle bundle);
    Bundle getBundle();
}

Oppure utilizzare seguendo questo listener generico per la comunicazione bidirezionale tramite l'interfaccia

 /**
 * Created by Qamar4P on 10/11/2017.
 */
public interface GenericConnector<T,E> {
    T getData();
    void updateData(E data);
    void connect(GenericConnector<T,E> connector);
}

metodo di visualizzazione dei frammenti

public static void show(AppCompatActivity activity) {
        CustomValueDialogFragment dialog = new CustomValueDialogFragment();
        dialog.connector = (GenericConnector) activity;
        dialog.show(activity.getSupportFragmentManager(),"CustomValueDialogFragment");
    }

puoi trasmettere il tuo contesto GenericConnectorinonAttach(Context) troppo

nella tua attività

CustomValueDialogFragment.show(this);

nel tuo frammento

...
@Override
    public void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        connector.connect(new GenericConnector() {
            @Override
            public Object getData() {
                return null;
            }

            @Override
            public void updateData(Object data) {

            }

            @Override
            public void connect(GenericConnector connector) {

            }
        });
    }
...
    public static void show(AppCompatActivity activity, GenericConnector connector) {
            CustomValueDialogFragment dialog = new CustomValueDialogFragment();
            dialog.connector = connector;
            dialog.show(activity.getSupportFragmentManager(),"CustomValueDialogFragment");
        }

Nota: non usarlo mai in questo "".toString().toString().toString();modo.

mi sono imbattuto in questa domanda, mentre la maggior parte dei metodi sopra funzionerà. Voglio solo aggiungere che è possibile utilizzare la libreria bus degli eventi , in particolare negli scenari in cui il componente (Activity o Fragment) non è stato creato, è utile per tutti i formati di progetti Android e molti casi d'uso. L'ho usato personalmente in diversi progetti che ho su Playstore.

È possibile creare un metodo statico pubblico in frammento in cui si otterrà un riferimento statico di quel frammento e quindi passare i dati a quella funzione e impostare tali dati su argomento nello stesso metodo e ottenere dati tramite getArgument sul metodo di frammento oncreate e impostare tali dati su locale variabili.

Il modo più intelligente provato e testato per passare i dati tra frammenti e attività è quello di creare una variabile, ad esempio:

class StorageUtil {
  public static ArrayList<Employee> employees;
}

Quindi per passare i dati dal frammento all'attività, lo facciamo nel metodo onActivityCreated:

//a field created in the sending fragment
ArrayList<Employee> employees;

@Override
    public void onActivityCreated(@Nullable Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
         employees=new ArrayList();

       //java 7 and above syntax for arraylist else use employees=new ArrayList<Employee>() for java 6 and below

     //Adding first employee
        Employee employee=new Employee("1","Andrew","Sam","1984-04-10","Male","Ghanaian");
        employees.add(employee);

      //Adding second employee
       Employee employee=new Employee("1","Akuah","Morrison","1984-02-04","Female","Ghanaian");
         employees.add(employee);

        StorageUtil.employees=employees;
    }

Ora puoi ottenere il valore di StorageUtil.employees da qualsiasi luogo. In bocca al lupo!

La mia soluzione è scrivere un metodo statico all'interno del frammento:

public TheFragment setData(TheData data) {
    TheFragment tf = new TheFragment();
    tf.data = data;
    return tf;
}

In questo modo sono sicuro che tutti i dati di cui ho bisogno si trovano all'interno del frammento prima di ogni altra possibile operazione che potrebbe aver bisogno di lavorare con esso. Inoltre sembra più pulito secondo me.

Ho riscontrato un problema simile durante l'utilizzo dell'ultimo componente dell'architettura di navigazione. Ho provato tutto il codice sopra menzionato passando un pacchetto dalla mia attività di chiamata a Frammento.

La migliore soluzione, seguendo le ultime tendenze di sviluppo in Android, è usando View Model (parte di Android Jetpack).

Crea e inizializza una classe ViewModel nell'attività principale, tieni presente che questo ViewModel deve essere condiviso tra l'attività e il frammento.

Ora, all'interno di onViewCreated () del frammento, inizializza lo stesso ViewModel e imposta gli osservatori per ascoltare i campi ViewModel.

Ecco un tutorial utile e approfondito, se necessario.

https://medium.com/mindorks/how-to-communicate-between-fragments-and-activity-using-viewmodel-ca733233a51c

Nella tua attività dichiarare variabile statica

public static HashMap<String,ContactsModal> contactItems=new HashMap<String, ContactsModal>();

Quindi nel tuo frammento fai come segue

ActivityName.contactItems.put(Number,contactsModal);