如何在片段之间传递值

小开

最佳答案

步骤1 : 将数据从片段发送到活动

Intent intent = new Intent(getActivity().getBaseContext(),
TargetActivity.class);
intent.putExtra("message", message);
getActivity().startActivity(intent);

步骤2 : 在活动中接收数据:

Intent intent = getIntent();
String message = intent.getStringExtra("message");

步骤3 : 要将数据从一个活动发送到另一个活动，请遵循常规方法

Intent intent = new Intent(MainActivity.this,
TargetActivity.class);
intent.putExtra("message", message);
startActivity(intent);

步骤4 : 在活动中接收此数据

  Intent intent = getIntent();
String message = intent.getStringExtra("message");

步骤5. : 从一个活动中，你可以将数据发送到一个片段，其意图如下:

Bundle bundle = new Bundle();
bundle.putString("message", "From Activity");


// Set Fragmentclass Arguments
Fragmentclass fragobj = new Fragmentclass();
fragobj.setArguments(bundle);

要接收片段 onCreateView 方法中的片段:

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


return inflater.inflate(R.layout.fragment, container, false);
}

小开

来自开发商网站:

通常，您希望一个片段与另一个片段通信，例如根据用户事件更改内容。所有的片段到片段的通信都是通过相关的活动完成的。两个碎片不应该直接交流。

您可以在活动的帮助下在片段之间进行通信，也可以使用这种方法在活动和片段之间进行通信。

请检查这个链接也。

小开

在片段之间进行通信相当复杂(我发现实现侦听器概念有点困难)。

通常使用“事件总线”来抽象这些通信。这是一个第三方库，它为您处理这种通信。

“ Otto”是一个经常被用来做这个的词，可能值得研究一下: http://square.github.io/otto/

小开

正如在开发人员网站上指出的

通常，您希望一个片段与另一个片段通信，例如根据用户事件更改内容。所有的片段到片段的通信都是通过相关的活动完成的。两个碎片不应该直接交流。

片段之间的通信应该通过相关的活动来完成。

让我们看看以下组件:

活动承载碎片并允许碎片通信

将发送数据的第一个片段

FragmentB 第二个片段，它将接收来自 < strong > FragmentA 的数据

片段 A 的实现是:

public class FragmentA extends Fragment
{
DataPassListener mCallback;
    

public interface DataPassListener{
public void passData(String data);
}


@Override
public void onAttach(Context context)
{
super.onAttach(context);
// This makes sure that the host activity has implemented the callback interface
// If not, it throws an exception
try
{
mCallback = (OnImageClickListener) context;
}
catch (ClassCastException e)
{
throw new ClassCastException(context.toString()+ " must implement OnImageClickListener");
}
}
    

public View onCreateView(LayoutInflater inflater, ViewGroup container,Bundle savedInstanceState)
{
// Suppose that when a button clicked second FragmentB will be inflated
// some data on FragmentA will pass FragmentB
// Button passDataButton = (Button).........
        

passDataButton.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
if (view.getId() == R.id.passDataButton) {
mCallback.passData("Text to pass FragmentB");
}
}
});
}
}

主要活动的实施是:

public class MainActivity extends ActionBarActivity implements DataPassListener{
    

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

if (findViewById(R.id.container) != null) {
if (savedInstanceState != null) {
return;
}
getFragmentManager().beginTransaction()
.add(R.id.container, new FragmentA()).commit();
}
}
    

@Override
public void passData(String data) {
FragmentB fragmentB = new FragmentB ();
Bundle args = new Bundle();
args.putString(FragmentB.DATA_RECEIVE, data);
fragmentB .setArguments(args);
getFragmentManager().beginTransaction()
.replace(R.id.container, fragmentB )
.commit();
}
}

片段 B 的实施是:

public class FragmentB extends Fragment{
final static String DATA_RECEIVE = "data_receive";
TextView showReceivedData;
    

@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
View view = inflater.inflate(R.layout.fragment_B, container, false);
showReceivedData = (TextView) view.findViewById(R.id.showReceivedData);
}
    

@Override
public void onStart() {
super.onStart();
Bundle args = getArguments();
if (args != null) {
showReceivedData.setText(args.getString(DATA_RECEIVE));
}
}
}

我希望这个能帮上忙。

小开

首先，所有的答案都是正确的。您可以使用 Intent传递除自定义对象之外的数据。

如果要传递自定义对象，则必须将 Serialazable或 Parcelable实现到自定义对象类。我觉得这太复杂了。

因此，如果您的项目很简单，尝试使用 DataCache。 参考文献: < a href = “ https://GitHub.com/kimkevin/AndroidDataCache”rel = “ nofollow noReferrer”> GitHub project CachePot

1- 将此设置为将发送数据的视图、活动或片段

DataCache.getInstance().push(obj);

2- 在任何地方获取数据，如下所示

public class MainFragment extends Fragment
{
private YourObject obj;


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


obj = DataCache.getInstance().pop(YourObject.class);


} //end onCreate()
} //end class MainFragment

小开

在片段之间传递参数。 这是一个相当晚回答这个问题，但它可以帮助某人！ Fragment_1.java

Bundle i = new Bundle();
i.putString("name", "Emmanuel");


Fragment_1 frag = new Fragment_1();
frag.setArguments(i);
FragmentManager fragmentManager = getFragmentManager();
fragmentManager.beginTransaction()
.replace(R.id.content_frame
, new Fragment_2())
.commit();

然后在你的 Fragment_2.java你可以得到参数通常在你的 onActivityCreated 例如:

 Intent intent = getActivity().getIntent();
if (intent.getExtras() != null) {
String name =intent.getStringExtra("name");
}

小开

//在片段 _ 1. java 中

Bundle bundle = new Bundle();
bundle.putString("key","abc"); // Put anything what you want


Fragment_2 fragment2 = new Fragment_2();
fragment2.setArguments(bundle);


getFragmentManager()
.beginTransaction()
.replace(R.id.content, fragment2)
.commit();

//在片段 _ 2. java 中

Bundle bundle = this.getArguments();


if(bundle != null){
// handle your code here.
}

希望这个能帮到你。

小开

我已经为像我这样的初学者做了一些非常简单的东西，我在我的 Activity _ main. xml文件中做了一个文本视图，然后输入:

id = index
visibility = invisible

然后我从第一个片段得到这个文本视图:

index = (Textview) getActivity().findviewbyid(R.id.index)
index.setText("fill me with the value")

然后在第二个片段中我得到了值:

index = (Textview) getActivity().findviewbyid(R.id.index)
String get_the_value= index.getText().toString();

小开

这个简单的实现有助于以一种简单的方式在片段之间传递数据。我们认为需要将数据从“ Frgment1”传递到“ Fragment2”

在 Fragment1中(设置要发送的数据)

 Bundle bundle = new Bundle();
bundle.putString("key","Jhon Doe"); // set your parameteres


Fragment2 nextFragment = new Fragment2();
nextFragment.setArguments(bundle);


FragmentManager fragmentManager = getActivity().getSupportFragmentManager();
fragmentManager.beginTransaction().replace(R.id.content_drawer, nextFragment).commit();

在 Fragment2onCreateView 方法中(获取参数)

String value = this.getArguments().getString("key");//get your parameters
Toast.makeText(getActivity(), value+" ", Toast.LENGTH_LONG).show();//show data in tost

小开

将数据从片段传递到另一个片段

来自第一个碎片

// Set data to pass
MyFragment fragment = new MyFragment(); //Your Fragment
Bundle bundle = new Bundle();
bundle.putInt("year", 2017)  // Key, value
fragment.setArguments(bundle);
// Pass data to other Fragment
getFragmentManager()
.beginTransaction()
.replace(R.id.content, fragment)
.commit();

On Second Fragment

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


Bundle bundle = this.getArguments();
if (bundle != null) {
Int receivedYear = bundle.getInt("year", ""); // Key, default value
}
}

小开

我认为解决这个问题的一个好方法是使用自定义接口。

假设您有两个片段(A 和 B) ，它们位于同一个活动中，并且您希望将数据从 A 发送到 B。

界面:

public interface OnDataSentListener{
void onDataSent(Object data);
}

活动:

    public class MyActivity extends AppCompatActivity{


private OnDataSentListener onDataSentListener;


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


FragmentTransaction trans = getFragmentManager().beginTransaction();


FragmentA fa = new FragmentA();
FragmentB fb = new FragmentB();


fa.setOnDataSentListener(new Listeners.OnDataSentListener() {
@Override
public void onDataSent(Object data) {
if(onDataSentListener != null)  onDataSentListener.onDataSent(data);
}
});


transaction.add(R.id.frame_a, fa);
transaction.add(R.id.frame_b, fb);


transaction.commit();
}


public void setOnDataSentListener(OnDataSentListener listener){
this.onDataSentListener = listener;
}
}

片段 A:

public class FragmentA extends Fragment{


private OnDataSentListener onDataSentListener;


private void sendDataToFragmentB(Object data){
if(onDataSentListener != null) onDataSentListener.onDataSent(data);
}


public void setOnDataSentListener(OnDataSentListener listener){
this.onDataSentListener = listener;
}
}

片段 B:

public class FragmentB extends Fragment{


private void initReceiver(){
((MyActivity) getActivity()).setOnDataSentListener(new OnDataSentListener() {
@Override
public void onDataSent(Object data) {
// Here you receive the data from fragment A
}
});
}
}

小开

在片段之间传递数据的最新解决方案可以通过使用像 ViewModel 和 LiveData 这样的 Android 架构组件来实现。有了这个解决方案，您就不需要为通信定义接口，并且由于配置更改，可以获得使用视图模型(如数据存活)的优势。

在这个解决方案中，通信中涉及的片段共享相同的视图模型对象，这些对象与它们的活动生命周期相关联。视图模型对象包含实时数据对象。一个片段设置要传递到实时数据对象上的数据，第二个片段观察者实时数据更改并接收数据。

下面是完整的例子: 使用 ViewModel 在 Android 片段之间传递数据

小开

在你的 第一个碎片中，输入这段代码:

editprofile.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {


Fragment_editprofile Fragment = new Fragment_editprofile();
.
.
.
Fragment.getintentdetails(tv_name.getText().toString(),
tv_mob.getText().toString(), tv_email.getText().toString(), tv_dob.getText().toString(),
tv_gender.getText().toString(), photointent);


}
});

在 第二个碎片中，创建如下方法:

public void getintentdetails(String name, String mobile, String email, String dob,
String gender, String photointent) {


this.name_str = name;
this.mob_str = mobile;
this.email_str = email;
this.dob_str = dob;
this.gender_str = gender;
this.photo_str = photointent;
}

然后在类级别定义一个变量:

String name_str, mob_str, dob_str, photo_str, email_str, gender_str;

然后在第二个片段中创建另一个方法来设置一个值:

setexistingdetails();


private void setexistingdetails() {


if(!name_str.equalsIgnoreCase(""))
(et_name).setText(name_str);
if(!mob_str.equalsIgnoreCase(""))
et_mobile.setText(mob_str);
if(!email_str.equalsIgnoreCase(""))
email_et.setText(email_str);
if(!dob_str.equalsIgnoreCase(""))
dob_et.setText(dob_str);
if(!gender_str.equalsIgnoreCase("")) {
if (gender_str.equalsIgnoreCase("m")){
male_radio.setChecked(true);
}
else {
female_radio.setChecked(true);
}
}
if(!photo_str.equalsIgnoreCase("")) {
try {
Picasso.get().load(Const.BASE_PATH+"include/sub-domain/GENIUS/"+photo_str).into(adminpropic_edit);
}
catch (Exception e) {
}
}
}

小开

你可以通过 ViewModel和 实时数据实现你的目标，作者 Arnav Rao被清除。现在我用一个例子来更清楚地说明这一点。

首先，假定的 ViewModel被命名为 SharedViewModel.java。

public class SharedViewModel extends ViewModel {
private final MutableLiveData<Item> selected = new MutableLiveData<Item>();


public void select(Item item) {
selected.setValue(item);
}
public LiveData<Item> getSelected() {
return selected;
}
}

那么 源代码片段就是我们想要发送数据的 MasterFragment.java。

public class MasterFragment extends Fragment {
private SharedViewModel model;


public void onViewCreated(@NonNull View view, Bundle savedInstanceState) {
super.onViewCreated(view, savedInstanceState);
model = new ViewModelProvider(requireActivity()).get(SharedViewModel.class);
itemSelector.setOnClickListener(item -> {


// Data is sent


model.select(item);
});
}
}

最后，目的地碎片是我们希望接收数据的 DetailFragment.java。

public class DetailFragment extends Fragment {


public void onViewCreated(@NonNull View view, Bundle savedInstanceState) {
super.onViewCreated(view, savedInstanceState);
SharedViewModel model = new ViewModelProvider(requireActivity()).get(SharedViewModel.class);
model.getSelected().observe(getViewLifecycleOwner(), { item ->


// Data is received


});
}
}

小开

Kotlin 的方式

使用在官方 ViewModel 文档建议的 SharedViewModel

一个活动中的两个或多个片段需要互相交流。想象一个普通的主人-细节的例子片段，其中有一个片段，用户在其中选择一个项类的内容的另一个片段这种情况从来不是琐碎的，因为两个片段都需要定义一些接口描述，并且所有者活动必须绑定另外，这两个片段必须处理这个场景其他片段尚未创建或可见。

可以通过使用 ViewModel 对象来解决这个常见的问题。这些片段可以使用它们的活动范围共享 ViewModel 处理这次通讯

首先实现 KTX 碎片来更容易地实例化视图模型

dependencies {
implementation "androidx.fragment:fragment-ktx:1.2.2"
}

然后，您只需将要与其他片段共享的数据放入视图模型中:

class SharedViewModel : ViewModel() {
val selected = MutableLiveData<Item>()


fun select(item: Item) {
selected.value = item
}
}

最后，在每个片段中实例化 viewModel，并从您想要设置数据的片段中设置 selected的值

片段 A

class MasterFragment : Fragment() {


private val model: SharedViewModel by activityViewModels()


override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
itemSelector.setOnClickListener { item ->
model.select(item)
}


}
}

然后，在片段目的地侦听这个值

碎片 B

 class DetailFragment : Fragment() {


private val model: SharedViewModel by activityViewModels()


override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
model.selected.observe(viewLifecycleOwner, Observer<Item> { item ->
// Update the UI
})
}
}

你也可以反其道而行之

小开

Bundle bundle = new Bundle();
bundle.putString("mykey","abc");
bundle.putString("mykey2","abc"); // Put anything what you want


Fragment fragment = new Fragment();
fragment2.setArguments(bundle);


getFragmentManager()
.beginTransaction()
.replace(R.id.content, fragment2)
.commit();


Bundle bundle = this.getArguments(); // in your fragment oncreate


if(bundle != null){
String mykey = bundle.getString("mykey");
String mykey2 = bundle.getString("mykey2");
}

小开

特别是现在 Android 团队正在推动更多地坚持单一活动模型，片段之间的沟通变得更加重要。LiveData 和 Interfaces 是解决这个问题的非常好的方法。但是现在 Google 终于解决了这个问题，并尝试使用 FragmentManager 提供一个更简单的解决方案。这就是在 Kotlin 可以做到的。

在接收器片段中，添加一个侦听器:

setFragmentResultListener(
"data_request_key",
lifecycleOwner,
FragmentResultListener { requestKey: String, bundle: Bundle ->
// Unpack the bundle and use data
val frag1Str = bundle.getString("frag1_data_key")


})

在寄件人片段(片段1) :

setFragmentResult(
"data_request_key",
bundleOf("frag1_data_key" to value)
)

请记住，此功能只能在片段 -ktx 版本1.3.0-alpha04及以上版本中使用。

学分和进一步阅读:

一种新的片段间数据传递方法

Android 片段: 片段结果

小开

您可以使用几种方法来实现同样的目标:

一种方法是在您的父活动中实现一个接口，这样 fragment1就可以通过调用这些接口方法将信息传递给它的父活动。类似地，您可以拥有一个由 bragment2实现的接口，这样父活动就可以将数据发送到 bragment2。
另一种更简单的方法是相互之间直接调用方法。可以通过使用框架 API 来获取它的父活动，然后通过在父活动中定义助手方法，可以直接从 bragment1调用该方法，并将信息传递给父活动。类似地，在父活动中，您可以使用框架 API 来获取对其任何子片段的引用，在您的示例中，这些子片段是 bragment2。然后，您可以在 bragment2中定义您自己的 helper 方法，这样您就可以从父活动中调用相同的方法，并将信息传递给 bragment2。

如何在片段之间传递值

文件 MainActivity Java

文件第二活动，Java

Kotlin 的方式

片段 A

碎片 B

如何在片段之间传递值

文件 MainActivity Java

文件 第二活动，Java

Kotlin 的方式

片段 A

碎片 B

文件第二活动，Java