package com.example.kucun2.ui.dingdan;//package com.example.kucun2;
import static android.content.ContentValues.TAG;
import android.animation.Animator;
import android.animation.Animator
ListenerAdapter;
import android.animation.ObjectAnimator;
import android.animation.ValueAnimator;
import android.app.AlertDialog;
import android.content.Context;
import android.graphics.Color;
import android.graphics.Typeface;
import android.os.Build;
import android.os.Bundle;
import android.util.Log;
import android.util.TypedValue;
import android.
view.Gravity;
import android.
view.LayoutInflater;
import android.
view.
View;
import android.
view.
ViewGroup;
import android.
view.
ViewTreeObserver;
import android.widget.Adapter
View;
import android.widget.ArrayAdapter;
import android.widget.Button;
import android.widget.FrameLayout;
import android.widget.HorizontalScroll
View;
import android.widget.LinearLayout;
import android.widget.PopupMenu;
import android.widget.Search
View;
import android.widget.Spinner;
import android.widget.TableLayout;
import android.widget.TableRow;
import android.widget.Toast;
import androidx.core.content.ContextCompat;
import androidx.fragment.app.Fragment;
import com.example.kucun2.R;
import com.example.kucun2.
View.HorizontalScrollText
View;
import com.example.kucun2.entity.Bancai;
import com.example.kucun2.entity.Chanpin;
import com.example.kucun2.entity.Chanpin_Zujian;
import com.example.kucun2.entity.Dingdan;
import com.example.kucun2.entity.Dingdan_chanpin_zujian;
import com.example.kucun2.entity.Dingdan_Chanpin;
import com.example.kucun2.entity.data.Data;
import java.util.Array
List;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.
List;
public class OrderDisplayFragment extends Fragment {
private TableLayout table;
private HorizontalScroll
View horizontalScroll
View;
private ValueAnimator scrollIndicatorAnimator;
private boolean isIndicatorVisible = false;
// 添加排序相关的成员变量
private int currentSortColumn = -1;
private boolean sortAscending = true;
private
List<Object[]> allTableRowsData = new Array
List<>();
// 添加搜索相关成员变量
private Search
View search
View;
private Spinner columnSelector;
private
List<Object[]> filteredTableRowsData = new Array
List<>();
/**
*加载初始化
* @param inflater The LayoutInflater object that can be used to inflate
* any
views in the fragment,
* @param container If non-null, this is the parent
view that the fragment's
* UI should be attached to. The fragment should not add the
view itself,
* but this can be used to generate the LayoutParams of the
view.
* @param savedInstanceState If non-null, this fragment is being re-constructed
* from a previous saved state as given here.
*
* @return
*/
@Override
public
View onCreate
View(LayoutInflater inflater,
ViewGroup container,
Bundle savedInstanceState) {
View view = inflater.inflate(R.layout.fragment_order_display, container, false);
table =
view.find
ViewById(R.id.orderTable);
horizontalScroll
View =
view.find
ViewById(R.id.horizontalScrollContainer);
View scrollIndicator =
view.find
ViewById(R.id.scroll_indicator);
// 获取搜索控件
search
View =
view.find
ViewById(R.id.search_
view);
columnSelector =
view.find
ViewById(R.id.column_selector);
// 初始化
表头选择器
initColumnSelector();
// 设置搜索监听
search
View.setOnQueryText
Listener(new Search
View.OnQueryText
Listener() {
@Override
public boolean onQueryTextSubmit(String query) {
applySearchFilter();
return true;
}
@Override
public boolean onQueryTextChange(String newText) {
applySearchFilter();
return true;
}
});
LinearLayout fixedSearchBar =
view.find
ViewById(R.id.fixedSearchBar);
View placeholder =
view.find
ViewById(R.id.search_bar_placeholder);
// 添加全局布局监听器以获取正确的搜索框高度
fixedSearchBar.get
ViewTreeObserver().addOnGlobalLayout
Listener(
new
ViewTreeObserver.OnGlobalLayout
Listener() {
@Override
public void onGlobalLayout() {
// 获取搜索框的实际高度
int searchBarHeight = fixedSearchBar.getHeight();
// 设置占位视图的高度
ViewGroup.LayoutParams params = placeholder.getLayoutParams();
params.height = searchBarHeight;
placeholder.setLayoutParams(params);
// 确保仅运行一次
fixedSearchBar.get
ViewTreeObserver().removeOnGlobalLayout
Listener(this);
}
}
);
Log.d(TAG, "onCreate
View: "+Data.dingdans.get(0).getNumber());
// 添加
表头
addTableHeader(table);
// 填充表格数据
fillTableData();
// 添加滚动监听
horizontalScroll
View.get
ViewTreeObserver().addOnScrollChanged
Listener(() -> {
int maxScroll = horizontalScroll
View.getChildAt(0).getWidth() -
horizontalScroll
View.getWidth();
int currentScroll = horizontalScroll
View.getScrollX();
if (currentScroll > 0 && maxScroll > 0) {
if (!isIndicatorVisible) {
showScrollIndicator();
}
// 更新滚动指示器位置
updateScrollIndicatorPosition(currentScroll, maxScroll);
} else {
hideScrollIndicator();
}
});
return
view;
}
/**
* 获取数据
*/
private void fillTableData() {
List<Dingdan> orders = Data.dingdans;
List<Dingdan_Chanpin> orderProducts = Data.dingdanChanpins;
List<Dingdan_chanpin_zujian> orderMaterials = Data.dingdanBancais;
for (Dingdan order : orders) {
for (Dingdan_Chanpin orderProduct : orderProducts) {
if (orderProduct.getDingdan().getId().equals(order.getId())) {
Chanpin product = orderProduct.getChanpin();
for (Chanpin_Zujian component : product.getChanpinZujian()) {
for (Dingdan_chanpin_zujian material : orderMaterials) {
// 创建行数据但不立即添加到表格
Object[] rowData = createRowData(
order, product,orderProduct, component, material
);
allTableRowsData.add(rowData);
filteredTableRowsData.add(rowData);
// if (material.getZujian() != null &&
// material.getZujian().getId().equals(component.getId())) {
//
// addTableRow(createRowData(
// order, product, component, material
// ));
// }
}
}
}
}
}
// 初始排序
sortTableData(-1, true); // 初始显示原始顺序
}
/**
* 排序表格数据并刷新显示
* @param columnIndex 要排序的列索引
* @param ascending 是否升序排列
*/
private void sortTableData(int columnIndex, boolean ascending) {
// 更新排序状态
if (columnIndex >= 0) {
if (currentSortColumn == columnIndex) {
// 相同列点击时切换排序方向
sortAscending = !ascending;
} else {
currentSortColumn = columnIndex;
sortAscending = true; // 新列默认升序
}
}
// 创建排序比较器
Comparator<Object[]> comparator = (row1, row2) -> {
if (currentSortColumn < 0) {
return 0; // 返回0表示相等，保持原顺序
}
Object value1 = row1[currentSortColumn];
Object value2 = row2[currentSortColumn];
if (value1 == null && value2 == null) return 0;
if (value1 == null) return -1;
if (value2 == null) return 1;
// 根据不同列数据类型定制比较规则
try {
// 数值列：2(数量), 5(板材/组件), 6(订购数量)
if (currentSortColumn == 2 || currentSortColumn == 5 || currentSortColumn == 6) {
double d1 = Double.parseDouble(value1.toString());
double d2 = Double.parseDouble(value2.toString());
return sortAscending ? Double.compare(d1, d2) : Double.compare(d2, d1);
}
// 其他列按字符串排序
else {
String s1 = value1.toString().toLowerCase();
String s2 = value2.toString().toLowerCase();
return sortAscending ? s1.compareTo(s2) : s2.compareTo(s1);
}
} catch (NumberFormatException e) {
// 解析失败时按字符串比较
String s1 = value1.toString().toLowerCase();
String s2 = value2.toString().toLowerCase();
return sortAscending ? s1.compareTo(s2) : s2.compareTo(s1);
}
};
// 刷新表格显示
Collections.sort(filteredTableRowsData, comparator);
// 刷新显示
refreshTableWithData(filteredTableRowsData);
}
/**
* 表格数据动态添加
* @param rowData
*/
private void addTableRow(Object[] rowData) {
TableRow row = new TableRow(requireContext());
TableLayout.LayoutParams rowParams = new TableLayout.LayoutParams(
TableLayout.LayoutParams.MATCH_PARENT,
TableLayout.LayoutParams.WRAP_CONTENT
);
row.setLayoutParams(rowParams);
row.setMinimumHeight(dpToPx(36));
for (int i = 0; i < rowData.length; i++) {
final Object data = rowData[i];
// 判断是否为操作列（最后一列）
if (i == rowData.length - 1) {
// 创建操作按钮
Button actionButton = new Button(requireContext());
actionButton.setText("操作");
actionButton.setTextSize(TypedValue.COMPLEX_UNIT_SP, 14);
actionButton.setBackgroundResource(R.drawable.btn_selector); // 自定义按钮样式
// 设置按钮点击监听器
actionButton.setOnClick
Listener(new
View.OnClick
Listener() {
@Override
public void onClick(
View v) {
handleRowAction(rowData,v);
}
});
// 设置按钮布局参数
TableRow.LayoutParams btnParams = new TableRow.LayoutParams(
0, // 宽度由权重控制
TableRow.LayoutParams.WRAP_CONTENT,
0.5f
);
btnParams.weight = 0.5f;
int margin = dpToPx(1);
btnParams.setMargins(margin, margin, margin, margin);
actionButton.setLayoutParams(btnParams);
actionButton.setHeight(11);
row.add
View(actionButton);
} else {
// 正常文本列的代码（保持原逻辑）
HorizontalScrollText
View text
View = new HorizontalScrollText
View(requireContext());
text
View.setText(String.valueOf(data));
text
View.setTextSize(TypedValue.COMPLEX_UNIT_SP, 14);
int padding = dpToPx(8);
text
View.setPadding(padding, padding / 2, padding, padding);
text
View.setMinWidth(dpToPx(50));
TableRow.LayoutParams colParams=null;
// 设置背景边框
text
View.setBackgroundResource(R.drawable.cell_border);
if ( data.toString().length() > 10){
colParams = new TableRow.LayoutParams(
0, // 宽度将由权重控制
TableRow.LayoutParams.MATCH_PARENT,
2.0f
);
colParams.weight = 2;
}else{
colParams = new TableRow.LayoutParams(
0, // 宽度将由权重控制
TableRow.LayoutParams.MATCH_PARENT,
1.0f
);
colParams.weight = 1;
}
text
View.setLayoutParams(colParams);
row.add
View(text
View);
}
}
table.add
View(row);
}
// 动态添加
表头 (使用自定义Text
View)
private void addTableHeader(TableLayout table) {
TableRow headerRow = new TableRow(requireContext());
headerRow.setLayoutParams(new TableLayout.LayoutParams(
TableLayout.LayoutParams.MATCH_PARENT,
TableLayout.LayoutParams.WRAP_CONTENT
));
// 设置行背景颜色
headerRow.setBackgroundColor(ContextCompat.getColor(requireContext(), R.color.purple_500));
// 定义
表头
// 更新
表头数组（添加操作列）
String[] headers = getResources().getStringArray(R.array.table_headers);
List<String> header
List = new Array
List<>(Arrays.as
List(headers));
header
List.add("操作"); // 添加操作列标题
headers = header
List.toArray(new String[0]);
// 更新权重数组（添加操作列权重）
float[] weights = {1.0f, 1.0f, 1.0f, 1.0f, 2.0f, 1.0f, 1.0f, 0.5f}; // 新增操作列权重0.5
// 更新优先级数组（添加操作列优先级）
boolean[] priority = {false, false, false, false, true, false, false, false};
for (int i = 0; i < headers.length; i++) {
HorizontalScrollText
View header
View = new HorizontalScrollText
View(requireContext());
header
View.setText(headers[i]);
header
View.setTextColor(Color.WHITE);
header
View.setTypeface(null, Typeface.BOLD);
header
View.setTextSize(TypedValue.COMPLEX_UNIT_SP, 16);
header
View.setPadding(dpToPx(8), dpToPx(8), dpToPx(8), dpToPx(8));
// 为优先级高的列设置最小宽度
if (priority[i]) {
header
View.setMinWidth(dpToPx(220));
}
// 设置布局参数
TableRow.LayoutParams colParams = new TableRow.LayoutParams(
priority[i] ? TableRow.LayoutParams.WRAP_CONTENT : 0,
TableRow.LayoutParams.MATCH_PARENT,
priority[i] ? 0 : weights[i] // 优先级列不使用权重
);
header
View.setLayoutParams(colParams);
final int columnIndex = i;
header
View.setOnClick
Listener(v -> {
// 排序并刷新表格
sortTableData(columnIndex, sortAscending);
// 更新排序指示器（可选）
showSortIndicator(header
View);
});
headerRow.add
View(header
View);
}
table.add
View(headerRow);
}
// 添加排序指示器（可选）
private void showSortIndicator(
View header) {
// 实现：在
表头右侧添加↑或↓指示符
// 实现逻辑根据设计需求
// header.setTooltipText(new );
}
/**
*
*/
private void showScrollIndicator() {
isIndicatorVisible = true;
View indicator = get
View().find
ViewById(R.id.scroll_indicator);
if (scrollIndicatorAnimator != null && scrollIndicatorAnimator.isRunning()) {
scrollIndicatorAnimator.cancel();
}
indicator.setVisibility(
View.VISIBLE);
indicator.setAlpha(0f);
scrollIndicatorAnimator = ObjectAnimator.ofFloat(indicator, "alpha", 0f, 0.8f);
scrollIndicatorAnimator.setDuration(300);
scrollIndicatorAnimator.start();
}
/**+
*
*/
private void hideScrollIndicator() {
isIndicatorVisible = false;
View indicator = get
View().find
ViewById(R.id.scroll_indicator);
if (scrollIndicatorAnimator != null && scrollIndicatorAnimator.isRunning()) {
scrollIndicatorAnimator.cancel();
}
scrollIndicatorAnimator = ObjectAnimator.ofFloat(indicator, "alpha", indicator.getAlpha(), 0f);
scrollIndicatorAnimator.setDuration(300);
scrollIndicatorAnimator.add
Listener(new Animator
ListenerAdapter() {
@Override
public void onAnimationEnd(Animator animation) {
indicator.setVisibility(
View.INVISIBLE);
}
});
scrollIndicatorAnimator.start();
}
/**
*
* @param currentScroll
* @param maxScroll
*/
private void updateScrollIndicatorPosition(int currentScroll, int maxScroll) {
View indicator = get
View().find
ViewById(R.id.scroll_indicator);
FrameLayout.LayoutParams params = (FrameLayout.LayoutParams) indicator.getLayoutParams();
// 计算指示器位置（0-100%）
float percentage = (float) currentScroll / maxScroll;
int maxMargin = getResources().getDisplayMetrics().widthPixels - indicator.getWidth();
// 设置右边距（控制位置）
params.rightMargin = (int) (maxMargin * percentage);
indicator.setLayoutParams(params);
}
// 处理行操作的方法
private void handleRowAction(Object[] rowData ,
View anchorButton) {
// 安全地从行数据中提取关键信息
String orderNumber = safeGetString(rowData[0]); // 订单号
String productId = safeGetString(rowData[1]); // 产品ID
String componentName = safeGetString(rowData[3]); // 组件名称
// 安全地获取订购数量
double materialQuantity = 0.0;
try {
if (rowData[6] != null) {
if (rowData[6] instanceof Number) {
materialQuantity = ((Number) rowData[6]).doubleValue();
} else {
materialQuantity = Double.parseDouble(rowData[6].toString());
}
}
} catch (Exception e) {
Log.e("OrderFragment", "Failed to parse material quantity", e);
}
Context context = getContext();
if (context == null || anchorButton == null) {
Log.w("PopupMenu", "Context or anchorButton is null");
return;
}
PopupMenu popupMenu = new PopupMenu(context, anchorButton);
// 强制设置菜单在锚点视图下方显示（关键设置）
popupMenu.setGravity(Gravity.BOTTOM);
// 如果使用支持库，设置弹出方向
// 设置在锚点视图下方显示
// popupMenu.setOverlapAnchor(true);
// 填充菜单项
popupMenu.getMenuInflater().inflate(R.menu.row_actions_menu, popupMenu.getMenu());
// 设置菜单项点击监听器
popupMenu.setOnMenuItemClick
Listener(item -> {
int itemId = item.getItemId();
if (itemId == R.id.action_
view_details) {
showDetailDialog(orderNumber, productId);
return true;
} else if (itemId == R.id.action_edit) {
editRowData(rowData);
return true;
} else if (itemId == R.id.action_delete) {
deleteRowWithConfirm(rowData);
return true;
}
return false;
});
popupMenu.show();
}
// 安全获取字符串值的方法
private String safeGetString(Object value) {
if (value == null) return "";
if (value instanceof String) return (String) value;
return value.toString();
}
// 查看详情对话框
private void showDetailDialog(String orderNumber, String productId) {
AlertDialog.Builder builder = new AlertDialog.Builder(requireContext());
builder.setTitle("订单详情")
.setMessage("订单号: " + orderNumber + "\n产品ID: " + productId)
.setPositiveButton("确定", null)
.show();
}
// 编辑行数据
private void editRowData(Object[] rowData) {
// 实现编辑逻辑
// 这里创建包含表单的对话框
Toast.makeText(requireContext(), "编辑操作: " + rowData[0], Toast.LENGTH_SHORT).show();
}
// 带确认的删除操作
private void deleteRowWithConfirm(Object[] rowData) {
new AlertDialog.Builder(requireContext())
.setTitle("确认删除")
.setMessage("确定要删除订单 " + rowData[0] + " 吗?")
.setPositiveButton("删除", (dialog, which) -> {
// 实际删除逻辑
deleteRow(rowData);
})
.setNegativeButton("取消", null)
.show();
}
// 实际删除行数据
private void deleteRow(Object[] rowData) {
// 1. 从allTableRowsData中移除对应行
for (Iterator<Object[]> iterator = allTableRowsData.iterator(); iterator.hasNext();) {
Object[] row = iterator.next();
if (Arrays.equals(row, rowData)) {
iterator.remove();
break;
}
}
// 2. 从filteredTableRowsData中移除
filteredTableRowsData.removeIf(row -> Arrays.equals(row, rowData));
// 3. 刷新表格
refreshTableWithData(filteredTableRowsData);
Toast.makeText(requireContext(), "已删除订单", Toast.LENGTH_SHORT).show();
}
// DP转PX工具方法
private int dpToPx(int dp) {
return (int) TypedValue.applyDimension(
TypedValue.COMPLEX_UNIT_DIP,
dp,
getResources().getDisplayMetrics()
);
}
/**
* 数据组合
* @param order
* @param product
* @param component
* @param material
* @return
*/
private Object[] createRowData(Dingdan order, Chanpin product,Dingdan_Chanpin dingdan_chanpin,
Chanpin_Zujian component, Dingdan_chanpin_zujian material) {
Bancai board = material.getBancai();
String boardInfo = board.TableText(); ;
return new Object[] {
order.getNumber(), // 订单号
product.getBianhao(), // 产品编号
dingdan_chanpin.getShuliang(), // 产品数量 (根据需求调整)
component.getZujian().getName(), // 组件名
boardInfo, // 板材信息
Math.round(component.getOne_howmany()), // 板材/组件
material.getShuliang() , // 订购数量
"操作"
};
}
// 初始化列选择器
private void initColumnSelector() {
ArrayAdapter<CharSequence> adapter = ArrayAdapter.createFromResource(
requireContext(),
R.array.table_headers,
android.R.layout.simple_spinner_item
);
adapter.setDropDown
ViewResource(android.R.layout.simple_spinner_dropdown_item);
columnSelector.setAdapter(adapter);
// 添加"所有列"选项
columnSelector.setSelection(0); // 默认选择第一个选项（所有列）
// 列选择变化监听
columnSelector.setOnItemSelected
Listener(new Adapter
View.OnItemSelected
Listener() {
@Override
public void onItemSelected(Adapter
View<?> parent,
View view, int position, long id) {
applySearchFilter();
}
@Override
public void onNothingSelected(Adapter
View<?> parent) {}
});
}
// 应用搜索过滤
private void applySearchFilter() {
String query = search
View.getQuery().toString().trim().toLowerCase();
int selectedColumn = columnSelector.getSelectedItemPosition();
filteredTableRowsData.clear();
if (query.isEmpty()) {
// 没有搜索词，显示所有数据
filteredTableRowsData.addAll(allTableRowsData);
} else {
// 根据选择的列进行过滤
for (Object[] row : allTableRowsData) {
// 如果选择"所有列"（位置0），检查所有列
if (selectedColumn == 0) {
for (Object cell : row) {
if (cell != null && cell.toString().toLowerCase().contains(query)) {
filteredTableRowsData.add(row);
break;
}
}
}
// 检查特定列
else if (selectedColumn >= 1 && selectedColumn <= row.length) {
int columnIndex = selectedColumn - 1; // 调整索引（0=所有列，1=第一列）
if (row[columnIndex] != null &&
row[columnIndex].toString().toLowerCase().contains(query)) {
filteredTableRowsData.add(row);
}
}
}
}
// 刷新表格显示
refreshTableWithData(filteredTableRowsData);
}
/**
* 刷新表格显示
*/
private void refreshTableWithData(Iterable<? extends Object[]> dataToShow) {
// 移除除
表头外的所有行
removeAllRowsSafely();
// 添加过滤后的行
for (Object[] rowData : dataToShow) {
addTableRow(rowData);
}
}
private void removeAllRowsSafely() {
// 移除除
表头外的所有行（如果有
表头）
if (table.getChildCount() > 0) {
// 保留
表头（索引0）
for (int i = table.getChildCount() - 1; i >= 1; i--) {
View child = table.getChildAt(i);
table.remove
View(child);
// 清理视图引用（非常重要！）
cleanupRow
Views((TableRow) child);
}
}
}
private void cleanupRow
Views(TableRow row) {
int childCount = row.getChildCount();
for (int i = 0; i < childCount; i++) {
View view = row.getChildAt(i);
// 解除视图的所有监听器
view.setOnClick
Listener(null);
// 特别是操作按钮，需要取消所有监听器
if (
view instanceof Button) {
Button button = (Button)
view;
button.setOnClick
Listener(null);
// 清空按钮的数据引用
button.setTag(null);
}
}
// 从父视图中移除行
if (row.getParent() != null) {
((
ViewGroup) row.getParent()).remove
View(row);
}
}
}package com.example.kucun2.entity.data;
import android.util.Log;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChange
Listener;
import java.util.Array
List;
import java.util.Collection;
import java.util.Iterator;
import java.util.
List;
import java.util.
ListIterator;
/**
* 支持数据变更自动同步的泛型集合类
* 基于SynchronizableEntity的事件机制实现数据变更自动同步
*
* @param <T> 必须是SynchronizableEntity或其子类
*/
public class Synchronized
List<T extends SynchronizableEntity> implements
List<T> {
// 使用Array
List作为底层存储
private final
List<T>
list = new Array
List<>();
public Synchronized
List(Class T ) {
}
// 实体变更监听器
private final EntityChange
Listener<T> entityChange
Listener = new EntityChange
Listener<>();
@Override
public int size() {
return
list.size();
}
@Override
public boolean isEmpty() {
return
list.isEmpty();
}
@Override
public boolean contains(Object o) {
return
list.contains(o);
}
@Override
public Iterator<T> iterator() {
return new SyncedIterator<>(
list.iterator(), entityChange
Listener);
}
@Override
public Object[] toArray() {
return
list.toArray();
}
@Override
public <E> E[] toArray(E[] a) {
return
list.toArray(a);
}
// 添加元素时注册监听器
@Override
public boolean add(T element) {
if (element != null) {
element.addPropertyChange
Listener(entityChange
Listener);
}
Log.d("z","element");
return
list.add(element);
}
// 移除元素时注销监听器
@Override
public boolean remove(Object o) {
if (o instanceof SynchronizableEntity) {
((SynchronizableEntity) o).removePropertyChange
Listener(entityChange
Listener);
}
return
list.remove(o);
}
@Override
public boolean containsAll(Collection<?> c) {
return
list.containsAll(c);
}
// 批量添加时逐个注册监听器
@Override
public boolean addAll(Collection<? extends T> c) {
for (T element : c) {
if (element != null) {
element.addPropertyChange
Listener(entityChange
Listener);
}
}
return
list.addAll(c);
}
@Override
public boolean addAll(int index, Collection<? extends T> c) {
for (T element : c) {
if (element != null) {
element.addPropertyChange
Listener(entityChange
Listener);
}
}
return
list.addAll(index, c);
}
// 批量移除时逐个注销监听器
@Override
public boolean removeAll(Collection<?> c) {
for (Object o : c) {
if (o instanceof SynchronizableEntity) {
((SynchronizableEntity) o).removePropertyChange
Listener(entityChange
Listener);
}
}
return
list.removeAll(c);
}
@Override
public boolean retainAll(Collection<?> c) {
// 先移除未保留元素的监听器
for (T element :
list) {
if (!c.contains(element)) {
element.removePropertyChange
Listener(entityChange
Listener);
}
}
return
list.retainAll(c);
}
// 清空集合时移除所有监听器
@Override
public void clear() {
for (T element :
list) {
element.removePropertyChange
Listener(entityChange
Listener);
}
list.clear();
}
@Override
public T get(int index) {
return
list.get(index);
}
// 替换元素时更新监听器
@Override
public T set(int index, T element) {
T oldElement =
list.get(index);
if (oldElement != null) {
oldElement.removePropertyChange
Listener(entityChange
Listener);
}
if (element != null) {
element.addPropertyChange
Listener(entityChange
Listener);
}
return
list.set(index, element);
}
// 在指定位置添加元素时注册监听器
@Override
public void add(int index, T element) {
if (element != null) {
element.addPropertyChange
Listener(entityChange
Listener);
}
list.add(index, element);
}
// 移除元素时注销监听器
@Override
public T remove(int index) {
T removed =
list.remove(index);
if (removed != null) {
removed.removePropertyChange
Listener(entityChange
Listener);
}
return removed;
}
@Override
public int indexOf(Object o) {
return
list.indexOf(o);
}
@Override
public int lastIndexOf(Object o) {
return
list.lastIndexOf(o);
}
@Override
public
ListIterator<T>
listIterator() {
return new Synced
ListIterator<>(
list.
listIterator(), entityChange
Listener);
}
@Override
public
ListIterator<T>
listIterator(int index) {
return new Synced
ListIterator<>(
list.
listIterator(index), entityChange
Listener);
}
@Override
public
List<T> sub
List(int fromIndex, int toIndex) {
return
list.sub
List(fromIndex, toIndex);
}
/**
* 内部实体变更监听器
* 监听属性变化并触发同步操作
*/
private static class EntityChange
Listener<T extends SynchronizableEntity>
implements PropertyChange
Listener {
@Override
public void propertyChange(PropertyChangeEvent evt) {
@SuppressWarnings("unchecked")
T entity = (T) evt.getSource();
entity.sync(); // 触发同步操作
}
}
/**
* 增强的Iterator实现
* 移除元素时自动注销监听器
*/
private static class SyncedIterator<T extends SynchronizableEntity> implements Iterator<T> {
private final Iterator<T> iterator;
private final EntityChange
Listener<T>
listener;
private T current;
public SyncedIterator(Iterator<T> iterator, EntityChange
Listener<T>
listener) {
this.iterator = iterator;
this.
listener =
listener;
}
@Override
public boolean hasNext() {
return iterator.hasNext();
}
@Override
public T next() {
current = iterator.next();
return current;
}
@Override
public void remove() {
if (current != null) {
current.removePropertyChange
Listener(
listener);
}
iterator.remove();
}
}
/**
* 增强的
ListIterator实现
* 支持添加/设置元素时的监听器管理
*/
private static class Synced
ListIterator<T extends SynchronizableEntity>
implements
ListIterator<T> {
private final
ListIterator<T> iterator;
private final EntityChange
Listener<T>
listener;
private T lastReturned;
public Synced
ListIterator(
ListIterator<T> iterator, EntityChange
Listener<T>
listener) {
this.iterator = iterator;
this.
listener =
listener;
}
@Override
public boolean hasNext() {
return iterator.hasNext();
}
@Override
public T next() {
lastReturned = iterator.next();
return lastReturned;
}
@Override
public boolean hasPrevious() {
return iterator.hasPrevious();
}
@Override
public T previous() {
lastReturned = iterator.previous();
return lastReturned;
}
@Override
public int nextIndex() {
return iterator.nextIndex();
}
@Override
public int previousIndex() {
return iterator.previousIndex();
}
@Override
public void remove() {
if (lastReturned != null) {
lastReturned.removePropertyChange
Listener(
listener);
}
iterator.remove();
}
@Override
public void set(T e) {
if (lastReturned != null) {
lastReturned.removePropertyChange
Listener(
listener);
}
if (e != null) {
e.addPropertyChange
Listener(
listener);
}
iterator.set(e);
lastReturned = e;
}
@Override
public void add(T e) {
if (e != null) {
e.addPropertyChange
Listener(
listener);
}
iterator.add(e);
}
}
}package com.example.kucun2.entity.data;
import android.content.Context;
import android.util.Log;
import com.example.kucun2.entity.*;
import com.example.kucun2.function.MyAppFnction;
import com.example.kucun2.function.TLSUtils;
import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import java.io.IOException;
import java.lang.reflect.Type;
import java.util.*;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.X509TrustManager;
import okhttp3.Call;
import okhttp3.Callback;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
public class Data {
// 数据集合声明（保持原有属性名不变）
public static Synchronized
List<Bancai> bancais = new Synchronized
List<>(Bancai.class);
public static Synchronized
List<Caizhi> caizhis = new Synchronized
List<>(Caizhi.class);
public static Synchronized
List<Mupi> mupis = new Synchronized
List<>(Mupi.class);
public static Synchronized
List<Chanpin> chanpins = new Synchronized
List<>(Chanpin.class);
public static Synchronized
List<Chanpin_Zujian> chanpinZujians = new Synchronized
List<>(Chanpin_Zujian.class);
public static Synchronized
List<Dingdan> dingdans = new Synchronized
List<>(Dingdan.class);
public static Synchronized
List<Dingdan_Chanpin> dingdanChanpins = new Synchronized
List<>(Dingdan_Chanpin.class);
public static Synchronized
List<Dingdan_chanpin_zujian> dingdanBancais = new Synchronized
List<>(Dingdan_chanpin_zujian.class);
public static Synchronized
List<Kucun> kucuns = new Synchronized
List<>(Kucun.class);
public static Synchronized
List<Zujian> zujians = new Synchronized
List<>(Zujian.class);
public static Synchronized
List<User> users = new Synchronized
List<>(Bancai.class);
public static Synchronized
List<Jinhuo> jinhuo
List = new Synchronized
List<>(Bancai.class);
private static final Gson gson = new Gson();
private static OkHttpClient client ;
private static final String TAG = "DataLoader";
public static void loadAllData(Context context, LoadDataCallback callback) {
// 确保使用安全的客户端
if (client == null) {
client= MyAppFnction.getClient();
}
//禁用同步
SynchronizableEntity.setSyncEnabled(false);
String url = MyAppFnction.getStringResource("string", "url") +
MyAppFnction.getStringResource("string", "url_all");
Log.d("url", "loadAllData: " + url);
Request request = new Request.Builder()
.url(url)
.build();
client.newCall(request).enqueue(new Callback() {
@Override
public void onFailure(Call call, IOException e) {
Log.e(TAG, "Failed to load data", e);
SynchronizableEntity.setSyncEnabled(true);
if (callback != null) callback.onFailure();
}
@Override
public void onResponse(Call call, Response response) throws IOException {
if (!response.isSuccessful()) {
Log.e(TAG, "Unexpected response code: " + response.code());
if (callback != null) callback.onFailure();
return;
}
String responseData = response.body().string();
SynchronizableEntity.setSyncEnabled(true);
parseAndAssignData(responseData, context, callback);
}
});
}
// 解析并赋值数据
private static void parseAndAssignData(String jsonData, Context context, LoadDataCallback callback) {
// 创建包含所有数据类型的TypeToken
Type informationType = new TypeToken<Information<AllDataResponse>>(){}.getType();
Information<AllDataResponse> information = gson.fromJson(jsonData, informationType);
Log.e(TAG, "Invalid response data"+jsonData);
if (information == null || information.getData() == null || information.getStatus() != 200) {
Log.e(TAG, "Invalid response data");
if (callback != null) callback.onFailure();
return;
}
AllDataResponse allData = information.getData();
// 赋值到对应的列表（使用安全方法保持已有引用）
update
List(bancais, allData.bancais);
update
List(caizhis, allData.caizhis);
update
List(mupis, allData.mupis);
update
List(chanpins, allData.chanpins);
update
List(chanpinZujians, allData.chanpin_zujians);
update
List(dingdans, allData.dingdans);
update
List(dingdanChanpins, allData.dingdan_chanpins);
update
List(dingdanBancais, allData.dingdan_bancais);
update
List(kucuns, allData.kucuns);
update
List(zujians, allData.zujians);
update
List(users, allData.users);
update
List(jinhuo
List, allData.jinhuos);
// 在设置引用关系前关闭同步
SynchronizableEntity.setSyncEnabled(false);
resolveReferences();
// 为所有实体设置正确状态（已存在服务器）
setAllEntitiesState(SynchronizableEntity.SyncState.MODIFIED);
// 启用同步
SynchronizableEntity.setSyncEnabled(true);
if (callback != null) callback.onSuccess();
}
// 更新列表内容但保持对象引用不变
private static <T> void update
List(
List<T> existing
List,
List<T> new
List) {
if (new
List == null) return;
existing
List.clear();
existing
List.addAll(new
List);
}
// 解析对象间的引用关系（使用ID关联）
private static void resolveReferences() {
// 创建ID到对象的映射
Map<Integer, Bancai> bancaiMap = createIdMap(bancais);
Map<Integer, Caizhi> caizhiMap = createIdMap(caizhis);
Map<Integer, Mupi> mupiMap = createIdMap(mupis);
Map<Integer, Chanpin> chanpinMap = createIdMap(chanpins);
Map<Integer, Zujian> zujianMap = createIdMap(zujians);
Map<Integer, Dingdan> dingdanMap = createIdMap(dingdans);
Map<Integer, Kucun> kucunMap = createIdMap(kucuns);
// 解析Bancai引用
for (Bancai bancai : bancais) {
if (bancai.getCaizhi() != null) {
bancai.setCaizhi(caizhiMap.get(bancai.getCaizhi().getId()));
}
if (bancai.getMupi1() != null) {
bancai.setMupi1(mupiMap.get(bancai.getMupi1().getId()));
}
if (bancai.getMupi2() != null) {
bancai.setMupi2(mupiMap.get(bancai.getMupi2().getId()));
}
}
// 解析Kucun引用
for (Kucun kucun : kucuns) {
if (kucun.getBancai() != null) {
kucun.setBancai(bancaiMap.get(kucun.getBancai().getId()));
}
}
// 解析订单相关的嵌套对象
for (Dingdan_Chanpin dc : dingdanChanpins) {
if (dc.getDingdan() != null) {
dc.setDingdan(dingdanMap.get(dc.getDingdan().getId()));
}
if (dc.getChanpin() != null) {
dc.setChanpin(chanpinMap.get(dc.getChanpin().getId()));
}
}
// 解析产品相关的嵌套对象
for (Chanpin_Zujian cz : chanpinZujians) {
if (cz.getChanpin() != null) {
cz.setChanpin(chanpinMap.get(cz.getChanpin().getId()));
}
if (cz.getZujian() != null) {
cz.setZujian(zujianMap.get(cz.getZujian().getId()));
}
if (cz.getBancai() != null) {
cz.setBancai(bancaiMap.get(cz.getBancai().getId()));
}
}
// 解析库存关联
for (Kucun k : kucuns) {
if (k.getBancai() != null) {
k.setBancai(bancaiMap.get(k.getBancai().getId()));
}
}
}
// 创建ID到对象的映射
private static <T extends EntityClassGrassrootsid> Map<Integer, T> createIdMap(
List<T>
list) {
Map<Integer, T> map = new HashMap<>();
for (T item :
list) {
map.put(item.getId(), item);
}
return map;
}
// 回调接口
public interface LoadDataCallback {
void onSuccess();
void onFailure();
}
// 内部类用于解析JSON响应
public static class AllDataResponse {
public
List<Bancai> bancais;
public
List<Caizhi> caizhis;
public
List<Mupi> mupis;
public
List<Chanpin> chanpins;
public
List<Chanpin_Zujian> chanpin_zujians;
public
List<Dingdan> dingdans;
public
List<Dingdan_Chanpin> dingdan_chanpins;
public
List<Dingdan_chanpin_zujian> dingdan_bancais;
public
List<Kucun> kucuns;
public
List<Zujian> zujians;
public
List<User> users;
public
List<Jinhuo> jinhuos;
}
// 新增方法：设置所有实体状态
private static void setAllEntitiesState(SynchronizableEntity.SyncState state) {
set
ListState(bancais, state);
set
ListState(caizhis, state);
set
ListState(mupis, state);
set
ListState(dingdanBancais, state);
set
ListState(dingdans, state);
set
ListState(chanpins, state);
set
ListState(chanpinZujians, state);
set
ListState(zujians, state);
set
ListState(jinhuo
List, state);
set
ListState(kucuns, state);
set
ListState(users, state);
set
ListState(caizhis, state);
// ... 其他列表
}
private static <T extends SynchronizableEntity> void set
ListState(
List<T>
list, SynchronizableEntity.SyncState state) {
for (T entity :
list) {
entity.setState(state);
}
}
} 记录：onCreate
View: 鐩存帴鍏ュ簱 表格没数据
本文介绍了一个使用ASP.NET中ListView控件显示数据的具体示例。通过创建自定义类DataClass并实例化两个对象填充数据，然后使用ListView进行绑定展示。
扫一扫
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
