Enviar dados da atividade para fragmentar no Android

Eu tenho duas aulas Primeiro é a atividade, o segundo é um fragmento onde eu tenho alguns EditText. Na atividade, tenho uma subclasse com tarefa assíncrona e, no método doInBackground, obtenho algum resultado, que salvo na variável. Como posso enviar esta variável da subclasse "minha atividade" para este fragmento?

Em Activity, você envia dados com a intenção de:

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

e no 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);
}

Também é possível acessar dados da atividade do fragmento:

Atividade:

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

Encontrei muitas respostas aqui @ stackoverflow.com, mas definitivamente esta é a resposta correta de:

"Enviando dados da atividade para fragmentar no Android".

Atividade:

        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:

Lendo o valor no fragmento

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

ou apenas

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

Esta resposta pode ser tarde demais. mas será útil para futuros leitores.

Eu tenho alguns critérios. Eu codifiquei para escolher o arquivo da intenção. e arquivo selecionado a ser passado para um fragmento específico para posterior processo. Eu tenho muitos fragmentos com a funcionalidade de Seleção de arquivo. no momento, sempre que checar a condição e obter o fragmento e passar o valor, é bastante nojento. então, eu decidi passar o valor usando a interface.

Etapa 1: Crie a interface na Atividade Principal.

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

Etapa 2: criar a referência SelectedBundle na mesma atividade

   SelectedBundle selectedBundle;

Etapa 3: criar o método na mesma atividade

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

Etapa 4: é necessário inicializar a referência SelectedBundle, que é um fragmento, que precisa da funcionalidade filepicker. Você coloca esse código no onCreateView(..)método de fragmento

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

Etapa 5: meu caso, preciso passar a imagem Uri da HomeActivity para o fragmento. Então, eu usei essa funcionalidade no método onActivityResult.

onActivityResult do MainActivity, passe os valores para os fragmentos usando a interface.

Nota: Seu caso pode ser diferente. você pode chamá-lo de qualquer lugar da sua HomeActivity.

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

Isso é tudo. Implemente todos os fragmentos necessários na FragmentClass. Você é ótimo. você fez. UAU...

A idéia básica do uso de fragmentos (F) é criar componentes de interface do usuário auto-sustentáveis ​​reutilizáveis ​​em aplicativos Android. Esses fragmentos estão contidos em atividades e existem maneiras (melhores) comuns de criar caminhos de comunicação de A -> F e FA. É necessário se comunicar entre FF por meio de uma atividade, porque somente os fragmentos se dissociam e se sustentam.

Portanto, passar dados de A -> F será o mesmo que explicado por ρяσѕρєя K. Além dessa resposta, após a criação dos fragmentos dentro de uma atividade, também podemos passar dados para os fragmentos que chamam métodos em Fragmentos.

Por exemplo:

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

A abordagem melhor e conveniente é chamar instância de fragmento e enviar dados naquele momento. cada fragmento por padrão tem método de instância

Por exemplo: se o nome do seu fragmento for MyFragment

então você chamará seu fragmento de atividade como esta:

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

* R.id.container é um ID do meu FrameLayout

portanto, em MyFragment.newInstance ("data1", "data2"), você pode enviar dados para fragmentos e, no seu fragmento, obtém esses dados em 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, em seguida, no método de fragmento onCreate , você obterá os dados:

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

agora mParam1 tem data1 e mParam2 tem data2

agora você pode usar esse mParam1 e mParam2 em seu fragmento.

Gostaria de acrescentar aos iniciantes que a diferença entre as 2 respostas mais votadas aqui é dada pelo uso diferente de um fragmento.

Se você usar o fragmento na classe java em que possui os dados que deseja transmitir, poderá aplicar a primeira resposta para transmitir dados:

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

Se, no entanto, você usar, por exemplo, o código padrão fornecido pelo Android Studio para fragmentos com guias, esse código não funcionará.

Ele não funcionará mesmo se você substituir o PlaceholderFragment padrão por seu FragmentClasses e mesmo se você corrigir o FragmentPagerAdapter na nova situação, adicionando uma opção para getItem () e outra opção para getPageTitle () (como mostrado aqui )

Aviso: o clipe mencionado acima possui erros de código, que explicarei mais adiante aqui, mas é útil para ver como você passa do código padrão para o código editável para fragmentos com guias)! O restante da minha resposta faz muito mais sentido se você considerar as classes java e os arquivos xml desse clipe (representativo do primeiro uso de fragmentos de guias em um cenário para iniciantes).

O principal motivo pelo qual a resposta mais votada desta página não funcionará é que nesse código padrão para fragmentos com guias, os fragmentos são usados ​​em outra classe java: FragmentPagerAdapter!

Portanto, para enviar os dados, você é tentado a criar um pacote no MotherActivity e passá-lo no FragmentPagerAdapter, usando a resposta no.2.

Só que está errado de novo. ( Provavelmente você poderia fazer assim, mas é apenas uma complicação que não é realmente necessária ).

A maneira correta / mais fácil de fazer isso, eu acho, é passar os dados diretamente para o fragmento em questão, usando a resposta no.2. Sim, haverá um forte acoplamento entre a Atividade e o Fragmento, MAS, para fragmentos com guias, isso é o esperado. Eu aconselho você a criar os fragmentos com guias dentro da classe java MotherActivity (como subclasses, pois nunca serão usados ​​fora da MotherActivity) - é fácil, basta adicionar dentro da classe java MotherActivity quantos fragmentos precisar, como este:

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

Portanto, para passar dados da MotherActivity para um fragmento, será necessário criar Strings / Bundles particulares acima da atividade onCreate da sua Mãe - que você pode preencher com os dados que deseja passar aos fragmentos e transmiti-los através de um método criado após o onCreate (aqui chamado 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 então na classe fragment, você usa 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 você tiver consultas ao banco de dados, aconselho que você as faça no MotherActivity (e transmita seus resultados como Strings / Inteiros anexados a chaves dentro de um pacote, como mostrado acima), como dentro dos fragmentos com guias, sua sintaxe se tornará mais complexa (isso se torna getActivity () por exemplo, e getIntent se torna getActivity (). getIntent), mas você também tem a opção de fazer o que quiser.

Meu conselho para iniciantes é focar em pequenos passos. Primeiro, obtenha sua intenção de abrir uma atividade com guias muito simples, sem passar QUALQUER dado. Funciona? Abre as guias que você espera? Se não, por que?

Comece com isso e, aplicando soluções como as apresentadas neste clipe , veja o que está faltando. Para esse clipe específico, o mainactivity.xml nunca é mostrado. Isso certamente vai confundir você. Mas se você prestar atenção, verá que, por exemplo, o contexto (tools: context) está errado nos arquivos de fragmento xml. Cada XML de fragmento precisa apontar para a classe de fragmento correta (ou subclasse usando o separador $).

Você também verá que na classe java de atividade principal você precisa adicionar tabLayout.setupWithViewPager (mViewPager) - logo após a linha TabLayout tabLayout = (TabLayout) findViewById (R.id.tabs); sem essa linha, sua visualização não está realmente vinculada aos arquivos XML dos fragmentos, mas mostra APENAS o arquivo xml da atividade principal.

Além da linha na classe java de atividade principal, no arquivo XML de atividade principal, você precisa alterar as guias para se adequar à sua situação (por exemplo, adicionar ou remover TabItems). Se você não possui guias no XML da atividade principal, possivelmente não escolheu o tipo de atividade correto quando o criou em primeiro lugar (nova atividade - atividade com guias).

Observe que nos últimos 3 parágrafos eu falo sobre o vídeo! Então, quando digo XML de atividade principal, é o XML de atividade principal no vídeo, que na sua situação é o arquivo XML de MotherActivity.

Se você passar uma referência ao fragmento (subclasse concreta de) para a tarefa assíncrona, poderá acessar o fragmento diretamente.

Algumas maneiras de passar a referência de fragmento para a tarefa assíncrona:

• Se sua tarefa assíncrona for uma classe de pleno direito ( class FooTask extends AsyncTask), passe seu fragmento para o construtor.
• Se sua tarefa assíncrona for uma classe interna, apenas declare uma variável Fragment final no escopo em que a tarefa assíncrona é definida ou como um campo da classe externa. Você poderá acessar isso da classe interna.

Às vezes, você pode receber Intent em sua atividade e precisa passar as informações para seu fragmento de trabalho.
As respostas dadas são boas se você precisar iniciar o fragmento, mas se ele ainda setArguments()estiver funcionando, não será muito útil.
Outro problema ocorre se as informações passadas causarem interação com sua interface do usuário. Nesse caso, você não pode chamar algo assim myfragment.passData()porque o Android informa rapidamente que apenas o segmento que criou a exibição pode interagir.

Então, minha proposta é usar um receptor. Dessa forma, você pode enviar dados de qualquer lugar, incluindo a atividade, mas o trabalho será realizado no contexto do fragmento.

Nos seus fragmentos 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
    }
}

Na sua atividade:

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

Post muito antigo, ainda me atrevo a acrescentar uma pequena explicação que teria sido útil para mim.

Tecnicamente, você pode definir diretamente membros de qualquer tipo em um fragmento da atividade.
Então, por que Bundle?
O motivo é muito simples - o Bundle fornece uma maneira uniforme de lidar com:
- criação / abertura de fragmento
- reconfiguração (rotação da tela) - basta adicionar o pacote inicial / atualizado ao outState em onSaveInstanceState ()
- restauração do aplicativo depois de coletar lixo em segundo plano ( como na reconfiguração).

Você pode (se você gosta de experiências) criar uma solução alternativa em situações simples, mas a abordagem por Bundle simplesmente não vê diferença entre um fragmento e mil em um backstack - permanece simples e direto.
É por isso que a resposta da @Elenasys é a solução mais elegante e universal.
E é por isso que a resposta dada por @Martin tem armadilhas

a melhor abordagem para enviar dados da classe de atividade para o fragmento é passar por métodos setter. Gostar

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

e obtenha esses dados da classe facilmente.

Desde Activityque você enviar dados com Bundle como:

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

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

E no Fragmentmétodo onCreateView, obtenha os dados:

@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 for activitynecessário fragmentexecutar uma ação após a inicialização, a maneira mais fácil é activitychamar um método na fragmentinstância. No fragment, adicione um método:

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

e, em seguida, no activity, obtenha acesso ao fragmentusando o fragmentgerenciador e chame o 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 então o activitypode se comunicar diretamente com o fragmentchamando isso method.

Use a interface a seguir para se comunicar entre atividade e fragmento

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

Ou use o seguinte ouvinte genérico para comunicação bidirecional usando a interface

 /**
 * 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 exibição de fragmentos

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

você pode lançar o seu contexto para GenericConnectornos onAttach(Context)demais

na sua atividade

CustomValueDialogFragment.show(this);

no seu 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 use da mesma "".toString().toString().toString();maneira.

apenas tropeçou nessa questão, enquanto a maioria dos métodos acima funcionará. Quero apenas acrescentar que você pode usar a Biblioteca de Barramento de Eventos , especialmente em cenários em que o componente (Atividade ou Fragmento) não foi criado, o que é bom para todos os tamanhos de projetos Android e para muitos casos de uso. Eu pessoalmente o usei em vários projetos que tenho no playstore.

Você pode criar um método estático público no fragmento, onde você obterá uma referência estática desse fragmento e passará os dados para essa função, configurando esses dados para o argumento no mesmo método e obtendo dados via getArgument no método oncreate do fragmento, e configurando esses dados para o local variáveis.

A maneira mais inteligente de testar e testar os dados entre fragmentos e atividade é criar variáveis, por exemplo:

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

Em seguida, para passar dados de fragmento para atividade, fazemos isso no 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;
    }

Agora você pode obter o valor de StorageUtil.employees de qualquer lugar. Boa sorte!

Minha solução é escrever um método estático dentro do fragmento:

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

Dessa forma, tenho certeza de que todos os dados necessários estão dentro do Fragmento antes de qualquer outra operação possível que possa precisar trabalhar com ele. Também parece mais limpo na minha opinião.

Corri para um problema semelhante ao usar o componente de arquitetura de navegação mais recente. Tentei todo o código acima mencionado ao passar um pacote da minha atividade de chamada para o Fragment.

A melhor solução, seguindo as últimas tendências de desenvolvimento no Android, é usando o View Model (parte do Android Jetpack).

Crie e inicialize uma classe ViewModel na atividade pai. Observe que esse ViewModel deve ser compartilhado entre a atividade e o fragmento.

Agora, dentro do onViewCreated () do fragmento, inicialize o mesmo ViewModel e configure os observadores para ouvir os campos do ViewModel.

Aqui está um tutorial útil e detalhado, se você precisar.

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

Na sua atividade, declare variável estática

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

Então no seu fragmento faça o seguinte

ActivityName.contactItems.put(Number,contactsModal);