如何处理片段内的网络调用

Question

我有以下情况：

我有一个Activity 承载一个ViewPager，我有4 个Fragments；

开头的ViewPager包含片段A，

当用户在ViewPager上滑动时片段B进入ViewPager，然后片段C和片段D..等等……

现在，一旦 FragmentPagerAdapter 被实例化，至少会创建 2 个片段。

这带来了两个问题：

1. 每个Fragment都需要进行网络调用，但我不想做不必要的（如果用户从不滑动到Fragment B，我不想为Fragment B进行网络调用 );
2. 类似于 1.)，我需要在 Fragment 执行网络调用时显示 ProgessDialog，但如果用户从未访问过 Fragment B，我不想显示来自 Fragment B 的对话框...

请问在这种情况下我应该使用什么样的模式？

活动

public class PagerActivity extends ActionBarActivity {

@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.viewpager_layout);

ViewPager pager=(ViewPager)findViewById(R.id.pager);
TabPageIndicator tabs=(TabPageIndicator)findViewById(R.id.titles);

pager.setAdapter(buildAdapter());
tabs.setViewPager(pager);
getSupportActionBar().setDisplayHomeAsUpEnabled(true);
}
}

FragmentPagerAdapter

public class MyFragmentPagerAdapter extends FragmentPagerAdapter {


@Override
public int getCount() {
    return (4);
}

@Override
public Fragment getItem(int position) {


    if (position == 1) {
        if (dashbardFragment == null)
            dashbardFragment = DashBoardFragment.newInstance(position);
        return dashbardFragment;
    }
    if (position == 0) {
        if (listOfParticipantFragment == null)
            listOfParticipantFragment = ListOfParicipantsFragment
            .newInstance(position);
        return listOfParticipantFragment;
    }

}

1 个片段

public class ListOfParicipantsFragment extends Fragment {

public static ListOfParicipantsFragment newInstance(int position) {
    ListOfParicipantsFragment frag = new ListOfParicipantsFragment();
    return (frag);
}

public static String getTitle(Context ctxt, int position) {
    return myApplication.getContext().getResources().getString(R.string.list_of_participants_fragment_title);
}


@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
        Bundle savedInstanceState) {
    View result = inflater.inflate(R.layout.guest_list_fragment_layout,
            container, false);

    return (result);
}

Answer 1

试试这个，在每个fragmentoverride下面的方法中，当它可见时调用你的函数：

@Override
public void setUserVisibleHint(boolean isVisibleToUser) {
    super.setUserVisibleHint(isVisibleToUser);
    if(isVisible()){
        if(isVisibleToUser){
            Log.d("MyTag","My Fragment is visible");
        }else{
            Log.d("MyTag","My Fragment is not visible");
        }
    }
}

编辑

注意：这仅在使用 FragmentPagerAdapter 或 FragmentStatePagerAdapter 时有用

Answer 2

基本上你想要做的是，当你滑动时找到当前正在查看的片段。然后，进行网络呼叫。

您可以利用 ViewPager 侦听器在用户滑动到新页面时获得通知。文档：http://developer.android.com/reference/android/support/v4/view/ViewPager.OnPageChangeListener.html#onPageSelected(int)

这将为您提供视图的位置。但我假设你想要的是实际的片段，这有点棘手。

但是，这里已经回答了这个问题：Is it possible to access the current Fragment being viewed by a ViewPager?

希望对你有帮助

Answer 3

让我向你介绍我的想法：

• getCurrentItem()
ViewPager的方法
• getItem(int position)
FragmentPagerAdapter的方法返回与指定位置关联的Fragment。

您可以定义一个接口来保存网络 I/O 的方法，例如

public Interface INetworkOnFragment{
 void handle(){
         //...
           }  
}

并在您的片段上实现它并处理它们自己的业务逻辑（网络调用）。

在主 Activity 中，在 ViewPager 对象上设置 ViewPager.OnPageChangeListener，如下所示：

    pager.setOnPageChangeListener(new ViewPager.OnPageChangeListener(){
public void onPageScrollStateChanged(int state){
//donothing
}
public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels){
//donothing
}
public void onPageSelected(int position){
       INetworkOnFragment interface =(INetworkOnFragment) (pager.getAdapter().getItem(position));//get the current fragment and call handle method on it,dont need to care about whichever fragment it is . 
interface.handle()
}
});

最重要的是onPageSelected(int position)，在回调里面获取当前的fragment并调用handle方法，不管是哪个fragment都不需要关心。

记住handle方法是在Activity中调用的，而不是在fragment中调用的。所有的Network调用都是Interface的实现，这样在Activity中处理很容易。

Answer 4

从我的回答here中查看解决方案

1）创建LifecycleManager接口该接口将有两个方法（onPauseFragment和onResumeFragment），每个ViewPager的Fragment都会实现它
2）让每个Fragment实现接口
3) 在每个片段中实现接口方法 - 在onResumeFragment 中启动您的AsyncTask
4）在ViewPager换页时调用接口方法您可以在ViewPager上设置OnPageChangeListener，并在ViewPager每次换页时获取回调
5) 实现OnPageChangeListener 来调用您的自定义生命周期方法

Answer 5

为 FragmentStatePagerAdapter 创建一个页面进入视图方法，该方法在片段进入视图时调用片段上的方法。

在您的片段中实现 OnPageIntoView 接口。

public class SomethingDifferent extends Fragment implements OnPageIntoView {
...
/*
 * Called when this page comes into view
 * 
 * @see com.gosylvester.bestrides.SettingFragmentPagerSupport.MyAdapter.
 * OnPageIntoView#onPageIntoView()
 */
@Override
public void onPageIntoView() {
    // this is just some random example code
    // that does some heavy lifting it only runs when the fragment
    // frist comes into view
    if (fragmentActivity != null) {
        if (lrc == null) {
            lrc = new ClientServiceLocationRecorder(
                    new WeakReference<Context>(
                            fragmentActivity.getApplicationContext()),
                    lrcCallback);
        }

        // get a status message from the location recorder
        lrc.sndMessageToLocationRecorder(ServiceLocationRecorder.MSG_RECORD_STATUS);
    }
}

创建自定义 FragmentStatePagerAdapter 重写 setPrimaryItem 方法，如果对象可以转换为接口，则仅通过接口调用一次。

public static class MyAdapter extends FragmentStatePagerAdapter {

    public interface OnPageIntoView {
        public void onPageIntoView();
    }

    private Fragment mCurrentFragment;

    //bonus method to get the current fragment
    public Fragment getCurrentFragment() {
        return mCurrentFragment;
    }

    static int lastPosition = -1;

    @Override
    public void setPrimaryItem(ViewGroup container, int position,
            Object object) {
        //quickly determine if the primary item has changed
        //and one time only call through interface
        if (position != lastPosition) {
            lastPosition = position;
            //determine if this is fragment it should be but lets avoid 
            //class cast exceptions
            if (Fragment.class.isAssignableFrom(object.getClass())) {
                mCurrentFragment = ((Fragment) object);
                //determine if the onPageIntoView interface has
                //been implemented in the fragment
                //if so call the onPageIntoView
                if (OnPageIntoView.class.isAssignableFrom(mCurrentFragment
                        .getClass())) {
                    ((OnPageIntoView) mCurrentFragment).onPageIntoView();
                }
            }
        }
        super.setPrimaryItem(container, position, object);
    }
}

Answer 6

对我来说似乎很容易，你需要的是Fragments onResume() method。仅当您的片段对用户可见时才会调用。

您可以在此处添加逻辑来启动您的网络调用。 It guarantees that your fragment is in visible mode.

看到这个

但是，您可以使用 LoaderManager 和 AsyncTaskLoader 模式来优化网络调用逻辑。

加载程序负责屏幕方向更改并为您缓存数据。这样网络调用就不会为相同的操作启动两次。

来自 Android 文档

在 Android 3.0 中引入，加载器使异步加载变得容易 活动或片段中的数据。装载机具有以下特点：

They are available to every Activity and Fragment.
They provide asynchronous loading of data.
They monitor the source of their data and deliver new results 

当内容改变时。 当它们自动重新连接到最后一个加载器的光标时 在配置更改后重新创建。 因此，他们不需要重新查询他们的数据。

您可以使用任何异步 HTTP 库进行网络调用，例如 Retrofit

我找到了一个 AsyncTaskLoader 和 LoaderManager @this link 的教程，下面是 一些来自教程的引用

加载器并非微不足道，那么为什么要首先使用它们呢？嗯，在 大多数情况下，您会在与您相同的场景中使用它们 使用异步任务；事实上，一些加载器子类扩展了 AsyncTask。 就像 AsyncTasks 用于执行任何长时间运行的操作一样 会占用用户线程并最终抛出可怕的 应用程序无响应 (ANR)，加载程序以相同的方式执行 出于同样的目的。主要区别在于装载机是专门的 用于加载数据。因此，装载机提供了许多效率和 便利的好处。

Answer 7

@Andrew Carl 提供了一个好主意。我也在我的项目中使用了类似的方法。我认为它更笼统。

创建接口：

public interface ViewPagerFragment {
    void onSelected();

    void onDeselected();
}

还有这个常用的助手：

import android.support.v4.app.Fragment;
import android.support.v4.app.FragmentManager;
import android.support.v4.view.ViewPager;

public class ViewPagerHelper implements ViewPager.OnPageChangeListener {
    private final FragmentManager mFragmentManager;
    private final ViewPager mViewPager;
    private int mSelectedPage;

    public ViewPagerHelper(FragmentManager fragmentManager, ViewPager viewPager) {
        mFragmentManager = fragmentManager;
        mViewPager = viewPager;
        mSelectedPage = -1;
    }

    @Override
    public void onPageSelected(int position) {
        Fragment previous = findViewPagerChildFragment(mFragmentManager, mViewPager, mSelectedPage);
        if (previous instanceof ViewPagerFragment) {
            ((ViewPagerFragment) previous).onDeselected();
        }

        Fragment current = findViewPagerChildFragment(mFragmentManager, mViewPager, position);
        if (current instanceof ViewPagerFragment) {
            ((ViewPagerFragment) current).onSelected();
        }

        mSelectedPage = position;
    }

    @Override
    public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) {
        // empty
    }

    @Override
    public void onPageScrollStateChanged(int state) {
        // empty
    }

    public static Fragment findViewPagerChildFragment(FragmentManager manager, ViewPager pager, int position) {
        if (pager == null) {
            return null;
        }

        String tag = "android:switcher:" + pager.getId() + ":" + position;
        return manager.findFragmentByTag(tag);
    }
}

现在您可以将它们用于任何目的：

片段：

import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.support.v4.app.Fragment;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.TextView;
import android.widget.Toast;

public class MyFragment extends Fragment implements ViewPagerFragment {
    private boolean mSelected;

    public static MyFragment newInstance(int position) {
        Bundle args = new Bundle();
        args.putInt("position", position);

        MyFragment result = new MyFragment();
        result.setArguments(args);
        return result;
    }

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        TextView result = new TextView(inflater.getContext());
        result.setText("Position: " + getPosition());
        return result;
    }

    private int getPosition() {
        return getArguments().getInt("position");
    }

    @Override
    public void onSelected() {
        mSelected = true;
        start();
    }

    @Override
    public void onDeselected() {
        mSelected = false;
    }

    private void start() {
        final Handler handler = new Handler();
        handler.postDelayed(new Runnable() {
            @Override
            public void run() {
                Activity activity = getActivity();
                if (activity == null) {
                    return;
                }

                if (!mSelected) {
                    Toast.makeText(activity, "Fragment #" + getPosition() + " stopped", Toast.LENGTH_SHORT).show();
                    return;
                }

                TextView textView = (TextView) activity.findViewById(R.id.text);
                if (textView != null) {
                    textView.setText("Fragment #" + getPosition() + " works: " + System.nanoTime() % 10000);
                }

                handler.postDelayed(this, 150);
            }
        }, 150);
    }
}

活动：

import android.os.Bundle;
import android.support.v4.view.ViewPager;
import android.support.v7.app.ActionBarActivity;

public class MainActivity extends ActionBarActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        ViewPager viewPager = (ViewPager) findViewById(R.id.view_pager);
        viewPager.setOnPageChangeListener(new ViewPagerHelper(getSupportFragmentManager(), viewPager));
        viewPager.setAdapter(new MyAdapter(getSupportFragmentManager()));
    }
}

适配器：

import android.support.v4.app.Fragment;
import android.support.v4.app.FragmentManager;
import android.support.v4.app.FragmentPagerAdapter;

public class MyAdapter extends FragmentPagerAdapter {
    public MyAdapter(FragmentManager fm) {
        super(fm);
    }

    @Override
    public Fragment getItem(int position) {
        return MyFragment.newInstance(position);
    }

    @Override
    public int getCount() {
        return 42;
    }
}

在github上查看完整的演示。