如何删除viewpager2中无用的片段

jtoj6r0c  于 2021-08-20  发布在  Java
关注(0)|答案(1)|浏览(405)

如何摧毁 retain Fragments 或 unused Fragments ( Fragment 数字为1-4） ViewPager2 当正确的交换。我只要 retain one Fragment 左边 visible Fragment （片段5）？

  1. private static class SettingAdapter extends FragmentStateAdapter {
  3.     public SettingAdapter(@NonNull Fragment fragment) {
  4.         super(fragment);
  5.     }
  7.     public void destroyUnusedFragment(){
  8.         // ?
  9.     }
  11.     @NonNull
  12.     @Override
  13.     public Fragment createFragment(int position) {
  14.         Log.i("xxx", "createFragment: " + position);
  15.         switch (position) {
  16.             default:
  17.             case 0:
  18.                 return new Fragment1();
  19.             case 1:
  20.                 return new Fragment2();
  21.             case 2:
  22.                 return new Fragment3();
  23.             case 3:
  24.                 return new Fragment4();
  25.             case 4:
  26.                 return new Fragment5();
  27.             case 5:
  28.                 return new DispenserFragment();
  29.             case 6:
  30.                 return new Fragment7();
  31.             case 7:
  32.                 return new Fragment8();
  33.             case 8:
  34.                 return new Fragment9();
  35.             case 9:
  36.                 return new Fragment10();
  37.             case 10:
  38.                 return new Fragment11();
  39.             case 11:
  40.                 return new Fragment12();
  41.             case 12:
  42.                 return new Fragment13();
  43.             case 13:
  44.                 return new Fragment14();
  45.             case 14:
  46.                 return new Fragment15();
  47.         }
  48.     }
  50.     @Override
  51.     public int getItemCount() {
  52.         return 15;
  53.     }
  54. }
  56. // call above from onCreateView in Fragment
  58. String[] titles = getSettingTabTitlesRes(context);
  59. settingAdapter = new SettingAdapter(this);
  61. binding.settingViewpager.setOffscreenPageLimit(1);
  62. binding.settingViewpager.setAdapter(settingAdapter);
  64. new TabLayoutMediator(binding.settingTablayout, binding.settingViewpager, (tab, position) -> {
  65.     tab.setText(titles[position]);
  66. }).attach();


  1. package id.ctech.dispenser_pos.ui.fragment.setting.dispenser.view;
  3. import android.app.Activity;
  4. import android.content.Context;
  5. import android.content.DialogInterface;
  6. import android.graphics.Color;
  7. import android.os.Bundle;
  8. import android.util.Log;
  9. import android.view.LayoutInflater;
  10. import android.view.View;
  11. import android.view.ViewGroup;
  13. import androidx.annotation.NonNull;
  14. import androidx.annotation.Nullable;
  15. import androidx.appcompat.app.AlertDialog;
  16. import androidx.core.content.ContextCompat;
  17. import androidx.fragment.app.Fragment;
  19. import java.util.List;
  21. import id.ctech.dispenser_pos.R;
  22. import id.ctech.dispenser_pos.databinding.FragmentDispenserBinding;
  23. import id.ctech.dispenser_pos.db.local.datasource.setting.dispenser.dispenser.DispenserDataSource;
  24. import id.ctech.dispenser_pos.db.local.datasource.setting.dispenser.dispenser_brand.DispenserBrandDataSource;
  25. import id.ctech.dispenser_pos.db.local.datasource.setting.nozzle.NozzleDataSourceHelper;
  26. import id.ctech.dispenser_pos.db.local.datasource.setting.work_schedule.shift_work.ShiftWorkDataSourceHelper;
  27. import id.ctech.dispenser_pos.db.local.datasource.setting.work_schedule.work_schedule.WorkScheduleDataSourceHelper;
  28. import id.ctech.dispenser_pos.etc.ChooseColor;
  29. import id.ctech.dispenser_pos.etc.ThreadExecutors;
  30. import id.ctech.dispenser_pos.ui.activity.main.MainActivity;
  31. import id.ctech.dispenser_pos.ui.compound.table.listeners.ITableDataClickListener;
  32. import id.ctech.dispenser_pos.ui.compound.table.listeners.ITableDataLongClickListener;
  33. import id.ctech.dispenser_pos.ui.fragment.etc.DebouncedOnClickListener;
  34. import id.ctech.dispenser_pos.ui.fragment.setting.SettingFragment;
  35. import id.ctech.dispenser_pos.ui.fragment.setting.dispenser.model.Dispenser;
  36. import id.ctech.dispenser_pos.ui.fragment.setting.dispenser.model.DispenserBrand;
  37. import id.ctech.dispenser_pos.ui.fragment.setting.dispenser.presenter.DispenserPresenter;
  38. import id.ctech.dispenser_pos.ui.fragment.setting.dispenser.presenter.IDispenserPresenter;
  39. import id.ctech.dispenser_pos.ui.fragment.setting.dispenser.view.table.dispenser.DispenserDataAdapter;
  40. import id.ctech.dispenser_pos.ui.fragment.setting.dispenser.view.table.dispenser_brand.DispenserBrandDataAdapter;
  41. import id.ctech.dispenser_pos.ui.fragment.setting.nozzle.model.Nozzle;
  42. import id.ctech.dispenser_pos.ui.fragment.setting.user_account.model.UserAccount;
  43. import id.ctech.dispenser_pos.ui.fragment.setting.work_schedule.model.ShiftWork;
  44. import id.ctech.dispenser_pos.ui.fragment.setting.work_schedule.model.WorkSchedule;
  46. import static android.widget.Toast.LENGTH_SHORT;
  47. import static id.ctech.dispenser_pos.dev.dispenser.ENozzleStatus.IN_HOLSTER;
  48. import static id.ctech.dispenser_pos.etc.Common.ADMIN;
  49. import static id.ctech.dispenser_pos.etc.Common.getDispenser;
  50. import static id.ctech.dispenser_pos.etc.Common.getNozzles;
  51. import static id.ctech.dispenser_pos.etc.Common.getShiftWorks;
  52. import static id.ctech.dispenser_pos.etc.Common.getWorkSchedules;
  53. import static id.ctech.dispenser_pos.etc.CommonColor.readThemeFromPref;
  54. import static id.ctech.dispenser_pos.etc.CommonDate.toShortTime24;
  55. import static id.ctech.dispenser_pos.ui.compound.alert_dialog.SweetAlertDialog.showConfirmDialog;
  56. import static id.ctech.dispenser_pos.ui.compound.snackbar.SweetSnackbar.showSnackbarError;
  57. import static id.ctech.dispenser_pos.ui.compound.snackbar.SweetSnackbar.showSnackbarInfo;
  58. import static id.ctech.dispenser_pos.ui.compound.snackbar.SweetSnackbar.showSnackbarSuccess;
  60. public class DispenserFragment extends Fragment implements IDispenserView {
  61.     private final static int PREV_PAGE = 3;
  62.     private final static int NEXT_PAGE = 5;
  63.     private Context context;
  64.     private IDispenserPresenter iDispenserPresenter;
  65.     // Dispenser
  66.     private DispenserDataAdapter dispenserDataAdapter;
  67.     private Dispenser dispenserClicked = null, dispenserLongClicked = null;
  68.     private int dispenserClickedRowIndex = -1, dispenserLongClickedRowIndex = -1;
  69.     private int hiddenNewID;
  70.     // DispenserBrand
  71.     private DispenserBrandDataAdapter dispenserBrandDataAdapter;
  72.     private DispenserBrand dispenserBrandClicked = null, dispenserBrandLongClicked = null;
  73.     private int dispenserBrandClickedRowIndex = -1, dispenserBrandLongClickedRowIndex = -1;
  74.     private int dispenserBrandNewID;
  75.     private FragmentDispenserBinding binding;
  76.     private ThreadExecutors threadExecutors;
  77.     private UserAccount signInAccount;
  78.     //
  79.     private Dispenser dispenser;
  80.     private Nozzle[] nozzles;
  81.     private ShiftWork[] shiftWorks;
  82.     private WorkSchedule[] workSchedules;
  83.     private int nozzleQty;
  84.     private int shiftWorkQty;
  86.     public DispenserFragment() {
  87.     }
  89.     private void readDispenser() {
  90.         try {
  91.             dispenser = getDispenser(context);
  92.             if (dispenser == null) {
  93.                 showSnackbarError(getString(R.string.message_failed_to_load_dispenser_module), LENGTH_SHORT);
  94.             }
  95.         } catch (Exception ex) {
  96.             ex.printStackTrace();
  97.         }
  98.     }
  100.     private void readNozzles() {
  101.         try {
  102.             nozzles = getNozzles(context);
  103.             if (nozzles.length == 0) {
  104.                 showSnackbarError(getString(R.string.message_failed_to_load_nozzle_module), LENGTH_SHORT);
  105.             }
  106.         } catch (Exception ex) {
  107.             ex.printStackTrace();
  108.         }
  109.     }
  111.     private void readShiftWorks() {
  112.         try {
  113.             shiftWorks = getShiftWorks(context);
  114.             if (shiftWorks.length == 0) {
  115.                 showSnackbarError(getString(R.string.message_failed_to_load_shift_work_module), LENGTH_SHORT);
  116.             }
  117.         } catch (Exception ex) {
  118.             ex.printStackTrace();
  119.         }
  120.     }
  122.     private void readWorkSchedules() {
  123.         try {
  124.             workSchedules = getWorkSchedules(context);
  125.             if (workSchedules.length == 0) {
  126.                 showSnackbarError(getString(R.string.message_failed_to_load_work_schedule_module), LENGTH_SHORT);
  127.             }
  128.         } catch (Exception ex) {
  129.             ex.printStackTrace();
  130.         }
  131.     }
  133.     private void nozzleSync() {
  134.         try {
  135.             readDispenser();
  136.             readNozzles();
  138.             // nozzle sync
  139.             if (dispenser != null && nozzles != null) {
  140.                 nozzleQty = dispenser.getNozzleQty(); // references
  141.                 if (nozzleQty < nozzles.length) {
  142.                     for (int i = nozzleQty + 1; i <= nozzles.length; i++) {
  143.                         NozzleDataSourceHelper.deleteNozzle(context, i);
  144.                     }
  145.                 } else if (nozzleQty > nozzles.length) {
  146.                     for (int i = nozzles.length + 1; i <= nozzleQty; i++) {
  147.                         Nozzle nozzle = new Nozzle(i, i, 0, 0, 0, 0, IN_HOLSTER);
  148.                         NozzleDataSourceHelper.createNozzle(context, nozzle);
  149.                     }
  150.                 }
  151.                 nozzles = getNozzles(context);
  153.                 // nozzle validation
  154.                 nozzleQty = dispenser.getNozzleQty();
  155.                 if (nozzleQty != nozzles.length) {
  156.                     showSnackbarError(getString(R.string.message_nozzle_sync_failed), LENGTH_SHORT);
  157.                 }
  158.             }
  159.         } catch (Exception ex) {
  160.             ex.printStackTrace();
  161.         }
  162.     }
  164.     private void shiftWorkSync() {
  165.         try {
  166.             readDispenser();
  167.             readShiftWorks();
  169.             // shift work sync
  170.             if (dispenser != null && shiftWorks != null) {
  171.                 shiftWorkQty = dispenser.getShiftWorkQty(); // references
  172.                 if (shiftWorkQty < shiftWorks.length) {
  173.                     for (int i = shiftWorkQty + 1; i <= shiftWorks.length; i++) {
  174.                         ShiftWorkDataSourceHelper.deleteShiftWork(context, i);
  175.                     }
  176.                 } else if (shiftWorkQty > shiftWorks.length) {
  177.                     for (int i = shiftWorks.length + 1; i <= shiftWorkQty; i++) {
  178.                         String strTime24 = "";
  179.                         switch (i) {
  180.                             case 1:
  181.                                 strTime24 = "06:00";
  182.                                 break;
  183.                             case 2:
  184.                                 strTime24 = "14:00";
  185.                                 break;
  186.                             case 3:
  187.                                 strTime24 = "22:00";
  188.                                 break;
  189.                         }
  190.                         // create shift work
  191.                         ShiftWork shiftWork = new ShiftWork(i, toShortTime24(strTime24));
  192.                         ShiftWorkDataSourceHelper.createShiftWork(context, shiftWork);
  193.                     }
  194.                 }
  195.                 shiftWorks = getShiftWorks(context);
  197.                 // shiftWorks validation
  198.                 shiftWorkQty = dispenser.getShiftWorkQty();
  199.                 if (shiftWorkQty != shiftWorks.length) {
  200.                     showSnackbarError(getString(R.string.message_shiftworks_sync_failed), LENGTH_SHORT);
  201.                 }
  202.             }
  203.         } catch (Exception ex) {
  204.             ex.printStackTrace();
  205.         }
  206.     }
  208.     private void workScheduleSync() {
  209.         try {
  210.             readDispenser();
  211.             readWorkSchedules();
  213.             // work schedule sync
  214.             if (dispenser != null && workSchedules != null) {
  215.                 nozzleQty = dispenser.getNozzleQty(); // references
  216.                 if (nozzleQty < workSchedules.length) {
  217.                     for (int i = nozzleQty + 1; i <= workSchedules.length; i++) {
  218.                         WorkScheduleDataSourceHelper.deleteWorkSchedule(context, i);
  219.                     }
  220.                 } else if (nozzleQty > workSchedules.length) {
  221.                     for (int i = workSchedules.length + 1; i <= nozzleQty; i++) {
  222.                         WorkSchedule workSchedule = new WorkSchedule(i, i, 1, 1, 1);
  223.                         WorkScheduleDataSourceHelper.createWorkSchedule(context, workSchedule);
  224.                     }
  225.                 }
  226.                 workSchedules = getWorkSchedules(context);
  228.                 // work schedule validation
  229.                 nozzleQty = dispenser.getNozzleQty();
  230.                 if (nozzleQty != workSchedules.length) {
  231.                     showSnackbarError(getString(R.string.message_workschedule_sync_failed), LENGTH_SHORT);
  232.                 }
  233.             }
  234.         } catch (Exception ex) {
  235.             ex.printStackTrace();
  236.         }
  237.     }
  239.     private void doSyncs() {
  240.         try {
  241.             nozzleSync();
  242.             shiftWorkSync();
  243.             workScheduleSync();
  244.         } catch (Exception ex) {
  245.             ex.printStackTrace();
  246.         }
  247.     }
  249.     @Override
  250.     public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
  251.         try {
  252.             Log.i("xxx", "DispenserFragment onCreateView");
  253.             context = getActivity();
  254.             if (context != null) {
  256.                 binding = FragmentDispenserBinding.inflate(inflater, container, false);
  257.                 View rootView = binding.getRoot();
  259.                 threadExecutors = ThreadExecutors.getInstance();
  261.                 doSyncs();
  263.                 DispenserDataSource dispenserDataSource = DispenserDataSource.getInstance(context);
  264.                 DispenserBrandDataSource dispenserBrandDataSource = DispenserBrandDataSource.getInstance(context);
  265.                 new DispenserPresenter(context, dispenserDataSource, dispenserBrandDataSource, this);
  267.                 // DispenserBrand
  268.                 binding.dispenserBrandAddButton.setOnClickListener(new DispenserBrandAddButtonClickListener());
  269.                 binding.dispenserBrandEditButton.setOnClickListener(new DispenserBrandEditButtonClickListener());
  270.                 binding.dispenserBrandDeleteButton.setOnClickListener(new DispenserBrandDeleteButtonClickListener());
  272.                 iDispenserPresenter.readDispenserBrands();
  274.                 // dispenser
  275.                 binding.dispenserPrevButton.setOnClickListener(new DispenserPrevButtonClickListener());
  276.                 binding.dispenserNextButton.setOnClickListener(new DispenserNextButtonClickListener());
  277.                 binding.dispenserAddButton.setOnClickListener(new DispenserAddButtonClickListener());
  278.                 binding.dispenserEditButton.setOnClickListener(new DispenserEditButtonClickListener());
  279.                 binding.dispenserDeleteButton.setOnClickListener(new DispenserDeleteButtonClickListener());
  281.                 signInAccount = ((MainActivity) getActivity()).getSignInAccount();
  283.                 iDispenserPresenter.readDispensers();
  285.                 setTheme(context);
  287.                 return rootView;
  288.             }
  289.         } catch (Exception ex) {
  290.             ex.printStackTrace();
  291.         }
  292.         return null;
  293.     }
  295.     private void setTheme(@NonNull Context context) {
  296.         try {
  297.             // set theme from pref
  298.             ChooseColor chooseColor = readThemeFromPref(context);
  299.             if (chooseColor != null) {
  300.                 context.setTheme(chooseColor.getTheme());     // app theme (default: R.style.app_theme_red)
  301.             }
  303.             Activity activity = getActivity();
  304.             if (activity != null) {
  305.                 int colorPrimary = ((MainActivity) activity).getColorPrimary();
  307.                 binding.dispenserAddButton.setBackgroundColor(colorPrimary);
  308.                 binding.dispenserDeleteButton.setBackgroundColor(colorPrimary);
  309.                 binding.dispenserEditButton.setBackgroundColor(colorPrimary);
  311.                 binding.dispenserPrevButton.setBackgroundColor(colorPrimary);
  312.                 binding.dispenserNextButton.setBackgroundColor(colorPrimary);
  314.                 binding.dispenserBrandAddButton.setBackgroundColor(colorPrimary);
  315.                 binding.dispenserBrandDeleteButton.setBackgroundColor(colorPrimary);
  316.                 binding.dispenserBrandEditButton.setBackgroundColor(colorPrimary);
  317.             }
  318.         } catch (Exception ex) {
  319.             ex.printStackTrace();
  320.         }
  321.     }
  323.     @Override
  324.     public void onDestroyView() {
  325.         super.onDestroyView();
  327.         Log.i("xxx", "DispenserFragment onDestroyView");
  329.         binding = null;
  330.         threadExecutors = null;
  331.         dispenserBrandDataAdapter = null;
  332.         dispenserBrandClicked = null;
  333.         dispenserBrandLongClicked = null;
  334.         dispenserDataAdapter = null;
  335.         dispenserClicked = null;
  336.         dispenserLongClicked = null;
  337.     }
  339.     @Override
  340.     public void setPresenter(@NonNull IDispenserPresenter iPresenter) {
  341.         iDispenserPresenter = iPresenter;
  342.     }
  344.     // DispenserBrand
  345.     @Override
  346.     public void onCreateDispenserBrand(boolean result) {
  347.         Runnable r = () -> {
  349.             try {
  350.                 if (binding == null) {
  351.                     return;
  352.                 }
  354.                 if (result) {
  355.                     showSnackbarSuccess(getString(R.string.message_successfully_to_save_data), LENGTH_SHORT);
  356.                     iDispenserPresenter.readDispenserBrands();
  357.                     binding.dispenserBrandAddButton.setText(getString(R.string.button_add));
  358.                     binding.dispenserBrandEditButton.setEnabled(true);
  359.                     binding.dispenserBrandDeleteButton.setEnabled(true);
  360.                     binding.dispenserBrandAddButton.setTextColor(Color.WHITE);
  361.                 } else {
  362.                     showSnackbarError(getString(R.string.message_failed_to_save_data), LENGTH_SHORT);
  363.                 }
  364.             } catch (Exception ex) {
  365.                 ex.printStackTrace();
  366.             }
  368.         };
  369.         threadExecutors.getMainThreadExecutor().execute(r);
  370.     }
  372.     @Override
  373.     public void onReadDispenserBrands(@NonNull List<DispenserBrand> dispenserBrandList) {
  374.         Runnable r = () -> {
  376.             try {
  377.                 if (binding == null) {
  378.                     return;
  379.                 }
  381.                 dispenserBrandDataAdapter = new DispenserBrandDataAdapter(context, dispenserBrandList, binding.dispenserBrandTable);
  382.                 dispenserBrandDataAdapter.setSelectedColor(-1);
  383.                 binding.dispenserBrandTable.setDataAdapter(dispenserBrandDataAdapter);
  384.                 binding.dispenserBrandTable.sort(0, true);
  385.                 binding.dispenserBrandTable.invalidate();
  386.                 binding.dispenserBrandTable.removeDataClickListener(new DispenserBrandClickListener());
  387.                 binding.dispenserBrandTable.removeDataLongClickListener(new DispenserBrandLongClickListener());
  388.                 binding.dispenserBrandTable.addDataClickListener(new DispenserBrandClickListener());
  389.                 binding.dispenserBrandTable.addDataLongClickListener(new DispenserBrandLongClickListener());
  390.                 dispenserBrandClickedRowIndex = -1;
  391.                 dispenserBrandClicked = null;
  392.                 dispenserBrandLongClickedRowIndex = -1;
  393.                 dispenserBrandLongClicked = null;
  394.             } catch (Exception ex) {
  395.                 ex.printStackTrace();
  396.             }
  398.         };
  399.         threadExecutors.getMainThreadExecutor().execute(r);
  400.     }
  402.     @Override
  403.     public void onUpdateDispenserBrand(boolean result) {
  404.         Runnable r = () -> {
  406.             try {
  407.                 if (binding == null) {
  408.                     return;
  409.                 }
  411.                 if (result) {
  412.                     showSnackbarSuccess(getString(R.string.message_successfully_to_save_data), LENGTH_SHORT);
  413.                     iDispenserPresenter.readDispenserBrands();
  414.                     binding.dispenserBrandEditButton.setText(getString(R.string.button_edit));
  415.                     binding.dispenserBrandAddButton.setEnabled(true);
  416.                     binding.dispenserBrandDeleteButton.setEnabled(true);
  417.                     binding.dispenserBrandEditButton.setTextColor(Color.WHITE);
  418.                 } else {
  419.                     showSnackbarError(getString(R.string.message_failed_to_save_data), LENGTH_SHORT);
  420.                 }
  421.             } catch (Exception ex) {
  422.                 ex.printStackTrace();
  423.             }
  425.         };
  426.         threadExecutors.getMainThreadExecutor().execute(r);
  427.     }
  429.     @Override
  430.     public void onDeleteDispenserBrand(boolean result) {
  431.         Runnable r = () -> {
  433.             try {
  434.                 if (binding == null) {
  435.                     return;
  436.                 }
  438.                 if (result) {
  439.                     showSnackbarSuccess(getString(R.string.message_data_deleted), LENGTH_SHORT);
  440.                 } else {
  441.                     showSnackbarError(getString(R.string.message_failed_to_delete_data), LENGTH_SHORT);
  442.                 }
  443.                 iDispenserPresenter.readDispenserBrands();
  444.                 binding.dispenserBrandAddButton.setEnabled(true);
  445.                 binding.dispenserBrandEditButton.setEnabled(true);
  446.             } catch (Exception ex) {
  447.                 ex.printStackTrace();
  448.             }
  450.         };
  451.         threadExecutors.getMainThreadExecutor().execute(r);
  452.     }
  454.     @Override
  455.     public void onNewIDDispenserBrand(int ID) {
  456.         Runnable r = () -> {
  458.             try {
  459.                 if (binding == null) {
  460.                     return;
  461.                 }
  463.                 dispenserBrandNewID = ID;
  464.                 dispenserBrandDataAdapter.add(new DispenserBrand(dispenserBrandNewID, ""));
  465.                 dispenserBrandDataAdapter.notifyDataSetChanged();
  466.                 binding.dispenserBrandTable.enterEditMode();
  467.             } catch (Exception ex) {
  468.                 ex.printStackTrace();
  469.             }
  471.         };
  472.         threadExecutors.getMainThreadExecutor().execute(r);
  473.     }
  475.     @Override
  476.     public void onErrorDispenserBrand(@NonNull Throwable result) {
  477.         Runnable r = () -> {
  479.             try {
  480.                 String strMessage = result.getMessage();
  481.                 if (strMessage != null) {
  482.                     showSnackbarError(strMessage, LENGTH_SHORT);
  483.                 }
  484.             } catch (Exception ex) {
  485.                 ex.printStackTrace();
  486.             }
  488.         };
  489.         threadExecutors.getMainThreadExecutor().execute(r);
  490.     }
  492.     // Dispenser
  493.     @Override
  494.     public void onCreateDispenser(boolean result) {
  495.         Runnable r = () -> {
  497.             try {
  498.                 if (binding == null) {
  499.                     return;
  500.                 }
  502.                 if (result) {
  503.                     showSnackbarSuccess(getString(R.string.message_successfully_to_save_data), LENGTH_SHORT);
  504.                     iDispenserPresenter.readDispensers();
  505.                     binding.dispenserAddButton.setText(getString(R.string.button_add));
  506.                     binding.dispenserEditButton.setEnabled(true);
  507.                     binding.dispenserDeleteButton.setEnabled(true);
  508.                     binding.dispenserAddButton.setTextColor(Color.WHITE);
  510.                     doSyncs();
  511.                 } else {
  512.                     showSnackbarError(getString(R.string.message_failed_to_save_data), LENGTH_SHORT);
  513.                 }
  514.             } catch (Exception ex) {
  515.                 ex.printStackTrace();
  516.             }
  518.         };
  519.         threadExecutors.getMainThreadExecutor().execute(r);
  520.     }
  522.     @Override
  523.     public void onReadDispensers(@NonNull List<Dispenser> result) {
  524.         Runnable r = () -> {
  526.             try {
  527.                 if (binding == null) {
  528.                     return;
  529.                 }
  531.                 dispenserDataAdapter = new DispenserDataAdapter(context, result, binding.dispenserTable);
  532.                 dispenserDataAdapter.setSelectedColor(-1);
  533.                 binding.dispenserTable.setDataAdapter(dispenserDataAdapter);
  534.                 binding.dispenserTable.sort(0, true);
  535.                 binding.dispenserTable.invalidate();
  536.                 binding.dispenserTable.removeDataClickListener(new DispenserClickListener());
  537.                 binding.dispenserTable.removeDataLongClickListener(new DispenserLongClickListener());
  538.                 binding.dispenserTable.addDataClickListener(new DispenserClickListener());
  539.                 binding.dispenserTable.addDataLongClickListener(new DispenserLongClickListener());
  540.                 dispenserClickedRowIndex = -1;
  541.                 dispenserClicked = null;
  542.                 dispenserLongClickedRowIndex = -1;
  543.                 dispenserLongClicked = null;
  544.             } catch (Exception ex) {
  545.                 ex.printStackTrace();
  546.             }
  548.         };
  549.         threadExecutors.getMainThreadExecutor().execute(r);
  550.     }
  552.     @Override
  553.     public void onUpdateDispenser(boolean result) {
  554.         Runnable r = () -> {
  556.             try {
  557.                 if (binding == null) {
  558.                     return;
  559.                 }
  561.                 if (result) {
  562.                     showSnackbarSuccess(getString(R.string.message_successfully_to_save_data), LENGTH_SHORT);
  563.                     iDispenserPresenter.readDispensers();
  564.                     binding.dispenserEditButton.setText(getString(R.string.button_edit));
  565.                     binding.dispenserAddButton.setEnabled(true);
  566.                     binding.dispenserDeleteButton.setEnabled(true);
  567.                     binding.dispenserEditButton.setTextColor(Color.WHITE);
  569.                     doSyncs();
  571.                 } else {
  572.                     showSnackbarError(getString(R.string.message_failed_to_save_data), LENGTH_SHORT);
  573.                 }
  574.             } catch (Exception ex) {
  575.                 ex.printStackTrace();
  576.             }
  578.         };
  579.         threadExecutors.getMainThreadExecutor().execute(r);
  580.     }
  582.     @Override
  583.     public void onDeleteDispenser(boolean result) {
  584.         Runnable r = () -> {
  586.             try {
  587.                 if (binding == null) {
  588.                     return;
  589.                 }
  591.                 if (result) {
  592.                     showSnackbarSuccess(getString(R.string.message_data_deleted), LENGTH_SHORT);
  594.                     doSyncs();
  596.                 } else {
  597.                     showSnackbarError(getString(R.string.message_failed_to_delete_data), LENGTH_SHORT);
  598.                 }
  599.                 iDispenserPresenter.readDispensers();
  600.                 binding.dispenserAddButton.setEnabled(true);
  601.                 binding.dispenserEditButton.setEnabled(true);
  602.             } catch (Exception ex) {
  603.                 ex.printStackTrace();
  604.             }
  606.         };
  607.         threadExecutors.getMainThreadExecutor().execute(r);
  608.     }
  610.     @Override
  611.     public void onNewIDDispenser(int ID) {
  612.         Runnable r = () -> {
  614.             try {
  615.                 if (binding == null) {
  616.                     return;
  617.                 }
  619.                 hiddenNewID = ID;
  620.                 // create default dispenser (dispenserId:1, dispenserType:new, nozzleQty:8, workScheduleQty:3)
  621.                 dispenserDataAdapter.add(new Dispenser(hiddenNewID, 1, 2, 8, 3));
  622.                 dispenserDataAdapter.notifyDataSetChanged();
  623.                 binding.dispenserTable.enterEditMode();
  624.             } catch (Exception ex) {
  625.                 ex.printStackTrace();
  626.             }
  628.         };
  629.         threadExecutors.getMainThreadExecutor().execute(r);
  630.     }
  632.     @Override
  633.     public void onErrorDispenser(@NonNull Throwable result) {
  634.         Runnable r = () -> {
  636.             try {
  637.                 String strMessage = result.getMessage();
  638.                 if (strMessage != null) {
  639.                     showSnackbarError(strMessage, LENGTH_SHORT);
  640.                 }
  641.             } catch (Exception ex) {
  642.                 ex.printStackTrace();
  643.             }
  645.         };
  646.         threadExecutors.getMainThreadExecutor().execute(r);
  647.     }
  649.     // DispenserBrand
  650.     private class DispenserBrandAddButtonClickListener extends DebouncedOnClickListener {
  652.         @Override
  653.         public void onDebouncedClick(final View v) {
  654.         }
  655.     }
  657.     private class DispenserBrandEditButtonClickListener extends DebouncedOnClickListener {
  659.         @Override
  660.         public void onDebouncedClick(View v) {
  661.         }
  662.     }
  664.     private class DispenserBrandDeleteButtonClickListener extends DebouncedOnClickListener {
  666.         @Override
  667.         public void onDebouncedClick(View v) {
  668.         }
  669.     }
  671.     private class DispenserBrandClickListener implements ITableDataClickListener<DispenserBrand> {
  672.         @Override
  673.         public void onDataClicked(int rowIndex, DispenserBrand clickedData) {
  674.         }
  675.     }
  677.     private class DispenserBrandLongClickListener implements ITableDataLongClickListener<DispenserBrand> {
  678.         @Override
  679.         public boolean onDataLongClicked(int rowIndex, DispenserBrand clickedData) {
  680.             return false;
  681.         }
  682.     }
  684.     // Dispenser
  685.     private class DispenserPrevButtonClickListener extends DebouncedOnClickListener {
  687.         @Override
  688.         public void onDebouncedClick(View v) {
  689.         }
  690.     }
  692.     private class DispenserNextButtonClickListener extends DebouncedOnClickListener {
  694.         @Override
  695.         public void onDebouncedClick(View v) {
  696.         }
  697.     }
  699.     private class DispenserAddButtonClickListener extends DebouncedOnClickListener {
  701.         @Override
  702.         public void onDebouncedClick(final View v) {
  703.         }
  704.     }
  706.     private class DispenserEditButtonClickListener extends DebouncedOnClickListener {
  708.         @Override
  709.         public void onDebouncedClick(View v) {
  710.         }
  711.     }
  713.     private class DispenserDeleteButtonClickListener extends DebouncedOnClickListener {
  715.         @Override
  716.         public void onDebouncedClick(View v) {
  717.         }
  718.     }
  720.     private class DispenserClickListener implements ITableDataClickListener<Dispenser> {
  721.         @Override
  722.         public void onDataClicked(int rowIndex, Dispenser clickedData) {
  723.         }
  724.     }
  726.     private class DispenserLongClickListener implements ITableDataLongClickListener<Dispenser> {
  727.         @Override
  728.         public boolean onDataLongClicked(int rowIndex, Dispenser clickedData) {
  729.             return false;
  730.         }
  731.     }
  733. }
JavaandroidFragmentfragmentstateadapter

1条答案

按热度按时间
jfgube3f

jfgube3f1#

viewpager2的错误，我得到如下解决方案：

  1. /**
  2.  * Sets whether the LayoutManager should be queried for views outside of
  3.  * its viewport while the UI thread is idle between frames.
  4.  *
  5.  * <p>If enabled, the LayoutManager will be queried for items to inflate/bind in between
  6.  * view system traversals on devices running API 21 or greater. Default value is true.</p>
  7.  *
  8.  * <p>On platforms API level 21 and higher, the UI thread is idle between passing a frame
  9.  * to RenderThread and the starting up its next frame at the next VSync pulse. By
  10.  * prefetching out of window views in this time period, delays from inflation and view
  11.  * binding are much less likely to cause jank and stuttering during scrolls and flings.</p>
  12.  *
  13.  * <p>While prefetch is enabled, it will have the side effect of expanding the effective
  14.  * size of the View cache to hold prefetched views.</p>
  15.  *
  16.  * @param enabled <code>True</code> if items should be prefetched in between traversals.
  17.  *
  18.  * @see #isItemPrefetchEnabled()
  19.  */
  20. RecyclerView.LayoutManager layoutManager =  ((RecyclerView)(binding.settingViewpager.getChildAt(0))).getLayoutManager();
  21. if(layoutManager != null) {
  22.     layoutManager.setItemPrefetchEnabled(false);
  23. }
  25. /**
  26.  * Set the number of offscreen views to retain before adding them to the potentially shared
  27.  * {@link #getRecycledViewPool() recycled view pool}.
  28.  *
  29.  * <p>The offscreen view cache stays aware of changes in the attached adapter, allowing
  30.  * a LayoutManager to reuse those views unmodified without needing to return to the adapter
  31.  * to rebind them.</p>
  32.  *
  33.  * @param size Number of views to cache offscreen before returning them to the general
  34.  *             recycled view pool
  35.  */ 
  36. RecyclerView recyclerView=  ((RecyclerView)(binding.settingViewpager.getChildAt(0)));
  37. if(recyclerView != null) {
  38.     recyclerView.setItemViewCacheSize(0);
  39. }
展开查看全部
赞(0）分享  回复(0）举报  2021-08-20
我来回答

相关问题

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新问答

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com