Enviar datos de la actividad a fragmentar en Android

Tengo dos clases Primero es actividad, segundo es un fragmento donde tengo algoEditText . En la actividad tengo una subclase con async-task y en el método doInBackgroundobtengo algún resultado, que guardo en la variable. ¿Cómo puedo enviar esta variable de la subclase "mi actividad" a este fragmento?

Desde Actividad, envía datos con intención como:

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

y en el método 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);
}

También puede acceder a los datos de actividad desde el fragmento:

Actividad:

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

Fragmento:

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

He encontrado muchas respuestas aquí @ stackoverflow.com pero definitivamente esta es la respuesta correcta de:

"Envío de datos de actividad a fragmento en Android".

Actividad:

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

Fragmento:

Leer el valor en el fragmento

        @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");
        ...
        ...
        ...
        }

Esta respuesta puede ser demasiado tarde. pero será útil para futuros lectores.

Tengo algunos criterios He codificado para elegir el archivo de la intención. y el archivo seleccionado para pasar a un fragmento particular para un proceso posterior. Tengo muchos fragmentos que tienen la funcionalidad de selección de archivos. en ese momento, cada vez que se verifica la condición y se obtiene el fragmento y se pasa el valor es bastante desagradable. Por lo tanto, he decidido pasar el valor utilizando la interfaz.

Paso 1: crea la interfaz en la actividad principal.

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

Paso 2: crear la referencia SelectedBundle en la misma actividad

   SelectedBundle selectedBundle;

Paso 3: crea el método en la misma actividad

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

Paso 4: necesita inicializar la referencia SelectedBundle, que son todos fragmentos, necesita la funcionalidad de selección de archivos. Coloque este código en su onCreateView(..)método de fragmento

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

Paso 5: Mi caso, necesito pasar la imagen Uri de HomeActivity a fragmentar. Entonces, utilicé esta funcionalidad en el método onActivityResult.

onActivityResult de MainActivity, pasa los valores a los fragmentos usando la interfaz.

Nota: su caso puede ser diferente. puede llamarlo desde cualquier lugar desde su HomeActivity.

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

Eso es todo. Implemente todos los fragmentos que necesita en FragmentClass. Eres genial. has hecho. GUAU...

La idea básica de usar Fragments (F) es crear componentes de interfaz de usuario autosustentables reutilizables en aplicaciones de Android. Estos Fragmentos están contenidos en actividades y hay una forma común (mejor) de crear vías de comunicación desde A -> F y FA. Es imprescindible comunicarse entre FF a través de una Actividad porque entonces solo los Fragmentos se desacoplan y se mantienen por sí mismos.

Por lo tanto, pasar datos de A -> F será el mismo que explica ρяσѕρєя K. Además de esa respuesta, después de la creación de los Fragmentos dentro de una Actividad, también podemos pasar datos a los fragmentos que invocan métodos en Fragmentos.

Por ejemplo:

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

El enfoque mejor y conveniente es llamar a la instancia de fragmento y enviar datos en ese momento. cada fragmento por defecto tiene método de instancia

Por ejemplo: si el nombre de su fragmento es MyFragment

entonces llamarás a tu fragmento de la actividad de esta manera:

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

* R.id.container es una identificación de mi FrameLayout

así que en MyFragment.newInstance ("data1", "data2") puede enviar datos a fragmentos y en su fragmento obtiene estos datos en 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;
    }

y luego en el método de fragmento onCreate obtendrás los datos:

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

así que ahora mParam1 tiene data1 y mParam2 tiene data2

ahora puede usar este mParam1 y mParam2 en su fragmento.

Me gustaría agregar para los principiantes que la diferencia entre las 2 respuestas más votadas aquí está dada por el uso diferente de un fragmento.

Si usa el fragmento dentro de la clase java donde tiene los datos que desea pasar, puede aplicar la primera respuesta para pasar los datos:

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

Sin embargo, si utiliza, por ejemplo, el código predeterminado proporcionado por Android Studio para fragmentos con pestañas, este código no funcionará.

No funcionará incluso si reemplaza el PlaceholderFragment predeterminado con sus FragmentClasses, e incluso si corrige el FragmentPagerAdapter a la nueva situación agregando un interruptor para getItem () y otro interruptor para getPageTitle () (como se muestra aquí )

Advertencia: el clip mencionado anteriormente tiene errores de código, que explicaré más adelante, pero es útil para ver cómo pasar del código predeterminado al código editable para fragmentos con pestañas). El resto de mi respuesta tiene mucho más sentido si considera las clases de Java y los archivos xml de ese clip (representativo del primer uso de fragmentos con pestañas en un escenario para principiantes).

La razón principal por la que la respuesta más votada de esta página no funcionará es que en ese código predeterminado para fragmentos con pestañas, los fragmentos se usan en otra clase de Java: ¡FragmentPagerAdapter!

Entonces, para enviar los datos, tiene la tentación de crear un paquete en MotherActivity y pasarlo en el FragmentPagerAdapter, utilizando la respuesta n. ° 2.

Solo que eso está mal otra vez. ( Probablemente podría hacerlo así, pero es solo una complicación que realmente no es necesaria ).

Creo que la forma correcta / más fácil de hacerlo es pasar los datos directamente al fragmento en cuestión, utilizando la respuesta n. ° 2. Sí, habrá un fuerte acoplamiento entre la Actividad y el Fragmento, PERO, para los fragmentos con pestañas, eso es algo esperado. Incluso te aconsejaría que crees los fragmentos con pestañas dentro de la clase java MotherActivity (como subclases, ya que nunca se usarán fuera de MotherActivity). Es fácil, solo agrega dentro de la clase java MotherActivity tantos Fragmentos como necesites así:

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

Por lo tanto, para pasar datos de MotherActivity a un Fragmento de este tipo, deberá crear cadenas / paquetes privados sobre la actividad onCreate of your Mother, que puede completar con los datos que desea pasar a los fragmentos y transmitirlos a través de un método creado después de onCreate (aquí llamado 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;
    }
}

Y luego, en la clase de fragmento, usas 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;
        }
    }

Si tiene consultas en la base de datos, le aconsejo que las haga en MotherActivity (y pase sus resultados como Strings / Integers adjuntos a las teclas dentro de un paquete como se muestra arriba), como dentro de los fragmentos con pestañas, su sintaxis se volverá más compleja (esto se vuelve getActivity () por ejemplo, y getIntent se convierte en getActivity (). getIntent), pero también tiene la opción de hacer lo que desee.

Mi consejo para principiantes es centrarse en pequeños pasos. Primero, obtenga su intención de abrir una actividad con pestañas muy simple, sin pasar CUALQUIER dato. ¿Funciona? ¿Abre las pestañas que esperas? Si no, ¿por qué?

Comience a partir de eso, y aplicando soluciones como las presentadas en este clip , vea lo que falta. Para ese clip en particular, el mainactivity.xml nunca se muestra. Eso seguramente te confundirá. Pero si presta atención, verá que, por ejemplo, el contexto (herramientas: contexto) es incorrecto en los archivos de fragmentos xml. Cada fragmento XML necesita apuntar a la clase de fragmento correcta (o subclase usando el separador $).

También verá que en la clase de actividad principal de Java necesita agregar tabLayout.setupWithViewPager (mViewPager) - justo después de la línea TabLayout tabLayout = (TabLayout) findViewById (R.id.tabs); sin esta línea, su vista en realidad no está vinculada a los archivos XML de los fragmentos, pero muestra SOLO el archivo xml de la actividad principal.

Además de la línea en la clase java de actividad principal, en el archivo XML de actividad principal debe cambiar las pestañas para que se ajusten a su situación (por ejemplo, agregar o quitar elementos de tabla). Si no tiene pestañas en el XML principal de la actividad, posiblemente no eligió el tipo de actividad correcto cuando lo creó en primer lugar (nueva actividad - actividad con pestañas).

¡Tenga en cuenta que en los últimos 3 párrafos hablo sobre el video! Entonces, cuando digo XML de actividad principal, es el XML de actividad principal en el video, que en su situación es el archivo XML de MotherActivity.

Si pasa una referencia al fragmento (subclase concreta de) en la tarea asincrónica, puede acceder al fragmento directamente.

Algunas formas de pasar la referencia del fragmento a la tarea asíncrona:

• Si su tarea asíncrona es una clase completa ( class FooTask extends AsyncTask), entonces pase su fragmento al constructor.
• Si su tarea asíncrona es una clase interna, simplemente declare una variable Fragmento final en el ámbito en que se define la tarea asíncrona, o como un campo de la clase externa. Podrá acceder a eso desde la clase interna.

A veces puede recibir Intención en su actividad y necesita pasar la información a su fragmento de trabajo.
Las respuestas dadas están bien si necesita comenzar el fragmento pero si aún funciona, setArguments()no es muy útil.
Otro problema ocurre si la información pasada hará que interactúe con su IU. En ese caso, no puede llamar a algo así myfragment.passData()porque Android le dirá rápidamente que solo el hilo que creó la vista puede interactuar.

Entonces mi propuesta es usar un receptor. De esa manera, puede enviar datos desde cualquier lugar, incluida la actividad, pero el trabajo se realizará dentro del contexto del fragmento.

En tu fragmento 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
    }
}

En tu actividad:

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

Publicación muy antigua, aun así me atrevo a agregar una pequeña explicación que me hubiera sido útil.

Técnicamente, puede establecer directamente miembros de cualquier tipo en un fragmento de la actividad.
Entonces, ¿por qué Bundle?
La razón es muy simple: Bundle proporciona una forma uniforme de manejar:
- creación / apertura de fragmentos
- reconfiguración (rotación de pantalla) - solo agregue paquete inicial / actualizado a outState en onSaveInstanceState ()
- restauración de la aplicación después de recolectar basura en segundo plano ( como con la reconfiguración).

Puede (si le gustan los experimentos) crear una solución en situaciones simples, pero el enfoque de paquete simplemente no ve la diferencia entre un fragmento y mil en un backstack: sigue siendo simple y directo.
Es por eso que la respuesta de @Elenasys es la solución más elegante y universal.
Y es por eso que la respuesta dada por @Martin tiene dificultades

El mejor enfoque para enviar datos de la clase de actividad al fragmento es pasar a través de métodos de establecimiento. Me gusta

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

y obtener estos datos de la clase fácilmente.

Desde Activityusted envía datos con Bundle como:

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

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

Y en el Fragmentmétodo onCreateView obtener los datos:

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

Si activitynecesita fragmentrealizar una acción después de la inicialización, la forma más fácil es activityinvocar un método en la fragmentinstancia. En el fragment, agregue un método:

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

y luego en el activity, obtenga acceso al fragmentuso del fragmentadministrador y llame al 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");
    }
}

y luego activitypueden comunicarse directamente con el fragmentinvocando esto method.

Use la siguiente interfaz para comunicarse entre la actividad y el fragmento

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

O utilice el seguimiento de este oyente genérico para la comunicación bidireccional usando la interfaz

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

método de presentación de fragmentos

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

puede emitir su contexto GenericConnectoren onAttach(Context)demasiado

en tu actividad

CustomValueDialogFragment.show(this);

en tu fragmento

...
@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: Nunca lo use de la misma "".toString().toString().toString();manera.

simplemente tropecé con esta pregunta, mientras que la mayoría de los métodos anteriores funcionarán. Solo quiero agregar que puede usar la Biblioteca de bus de eventos , especialmente en escenarios donde el componente (Actividad o Fragmento) no se ha creado, es bueno para todos los tamaños de proyectos de Android y muchos casos de uso. Lo he usado personalmente en varios proyectos que tengo en la tienda de juegos.

Puede crear un método estático público en un fragmento donde obtendrá una referencia estática de ese fragmento y luego pasar datos a esa función y establecer esos datos en argumentos en el mismo método y obtener datos a través de getArgument en un método de fragmento creado, y establecer esos datos en local variables

La forma más inteligente de pasar datos entre fragmentos y actividad es crear una variable, por ejemplo:

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

Luego, para pasar datos del fragmento a la actividad, lo hacemos en el método 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;
    }

Ahora puede obtener el valor de StorageUtil.employees de todas partes. ¡Buena suerte!

Mi solución es escribir un método estático dentro del fragmento:

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

De esta manera, estoy seguro de que todos los datos que necesito están dentro del Fragmento antes de cualquier otra operación posible que pueda necesitar trabajar con él. También se ve más limpio en mi opinión.

Me encontré con un problema similar al usar el último componente de arquitectura de navegación. Probé todo el código mencionado al pasar un paquete de mi actividad de llamadas a Fragment.

La mejor solución, siguiendo las últimas tendencias de desarrollo en Android, es usar View Model (parte de Android Jetpack).

Cree e inicialice una clase ViewModel en la Actividad principal. Tenga en cuenta que este ViewModel debe compartirse entre la actividad y el fragmento.

Ahora, dentro del onViewCreated () del fragmento, inicialice el mismo ViewModel y configure Observers para escuchar los campos ViewModel.

Aquí hay un tutorial útil y detallado si lo necesita.

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

En tu actividad declara variable estática

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

Entonces en tu fragmento haz como seguir

ActivityName.contactItems.put(Number,contactsModal);