上一篇文章讲述了ExpandableListView的基本使用
https://blog.csdn.net/qq_17846019/article/details/83276920
案例2之下的复杂案例的实现：
基于网络，SQLite、json数据的ExpandableListView的实现
先了解几个概念
Biz:(业务逻辑层)
- biz是Business的缩写，实际上就是控制层（业务逻辑层）。
解释：控制层的主要作用就是协调model层和view层直接的调用和转换。能够有效的避免请求直接进行数据库内容调用，而忽略了逻辑处理的部分。实际上biz就起到了一个server服务的角色，很好的沟通了上层和下层直接的转换，避免在model层进行业务处理（代码太混乱，不利于维护）。
- Dao：(数据访问层)
dao层：dao层叫数据访问层，全称为data access object，属于一种比较底层，一般用于数据库比较基础的操作，具体到对于某个表、某个实体的增删改
- bean（数据层）
javaBean在MVC设计模型中是model，又称模型层，在一般的程序中，我们称它为数据层，就是用来设置数据的属性和一些行为，然后我会提供获取属性和设置属性的get/set方法JavaBean是一种JAVA语言写成的可重用组件。
所以，我们一般利用bean类来存放一些特定的属性或行为，而不存放值，这样我们就能多次调用bean类中的属性并赋值使用，实现重复使用的功能。
- utils（工具类）
代码：
源码链接：链接: https://pan.baidu.com/s/1QE483Wm1J-iv82s5DHtDBg 提取码: 25av
下面直接贴代码：
1.布局文件
主布局：activity_main.xml
放置一个ExpandableListView 和一个Button
<?xml version="1.0" encoding="utf-8"?>
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent">
<ExpandableListView
xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:id="@+id/id_expandableLv"
android:childDivider="#414145"
tools:context=".MainActivity">
</ExpandableListView>
<Button
android:id="@+id/id_btn_refresh"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_gravity="right|bottom"
android:layout_margin="20dp"
android:text="刷新" />
</FrameLayout>父item的布局item_parent_list.xml
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:orientation="horizontal"
android:layout_width="match_parent"
android:layout_height="56dp">
<ImageView
android:id="@+id/item_parent_iv"
android:layout_width="30dp"
android:layout_height="30dp"
android:layout_marginStart="10dp"
tools:background="@drawable/indicator_expand"
android:layout_gravity="center_vertical"/>
<TextView
android:id="@+id/item_parent_tv"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:layout_marginStart="10dp"
android:textStyle="bold"
android:textSize="25dp"
android:gravity="center_vertical"
tools:text="Android"/>
</LinearLayout>子item的布局item_child_list.xml
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
xmlns:tools="http://schemas.android.com/tools"
android:orientation="horizontal">
<TextView
android:id="@+id/item_child_tv"
android:layout_width="match_parent"
android:layout_height="40dp"
android:layout_marginStart="20dp"
android:gravity="center_vertical"
android:textSize="20dp"
android:textStyle="bold"
tools:text="Andorid....."/>
</LinearLayout>2.bean类
父item的属性封装类Chapter.java
package com.demo.expandablelistviewdemo.bean;
import java.util.ArrayList;
import java.util.List;
/**
* 父布局的数据封装
*/
public class Chapter {
private String name;
private int id;
private List<ChapterItem> children=new ArrayList<>();
//数据库的属性
public static final String TABLE_NAME="tb_chapter";
public static final String COL_ID="_id";
public static final String COL_NAME="name";
public Chapter() {
}
public Chapter( int id,String name) {
this.name = name;
this.id = id;
}
//添加子item1
public void addChild(ChapterItem child){
children.add(child);
child.setPid(getId());
}
//添加子item方法2
public void addChild(int id,String childName){
ChapterItem chapterItem=new ChapterItem(id,childName);
chapterItem.setPid(getId());
children.add(chapterItem);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public List<ChapterItem> getChildren() {
return children;
}
public void setChildren(List<ChapterItem> children) {
this.children = children;
}
@Override
public String toString() {
return "Chapter{" +
"name='" + name + '\'' +
", id=" + id +
", children=" + children +
'}';
}
}
子item的属性封装类ChapterItem.java
package com.demo.expandablelistviewdemo.bean;
/**
* 子布局的数据封装
*/
public class ChapterItem {
private String name;
private int id;
private int pid;
//数据库的属性
public static final String TABLE_NAME = "tb_chapterItem";
public static final String COL_ID = "_id";
public static final String COL_NAME = "name";
public static final String COL_PID = "pid";
public ChapterItem() {
}
public ChapterItem(int id, String name) {
this.name = name;
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getPid() {
return pid;
}
public void setPid(int pid) {
this.pid = pid;
}
@Override
public String toString() {
return "ChapterItem{" +
"name='" + name + '\'' +
", id=" + id +
", pid=" + pid +
'}';
}
}
3.Dao类
dao层：dao层叫数据访问层，全称为data access object，属于一种比较底层，一般用于数据库比较基础的操作，具体到对于某个表、某个实体的增删改
ChapterDbHelper.java
实现数据库及表的创建
package com.demo.expandablelistviewdemo.dao;
import android.content.Context;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
import com.demo.expandablelistviewdemo.bean.Chapter;
import com.demo.expandablelistviewdemo.bean.ChapterItem;
/**
* 数据访问层
*/
public class ChapterDbHelper extends SQLiteOpenHelper {
private static final String DB_NAME = "db_chapter.db";
private static final int VERSION = 1;
//单例模式
private static ChapterDbHelper sInstance;
public static synchronized ChapterDbHelper getsInstance(Context context) {
if (sInstance == null)
sInstance = new ChapterDbHelper(context.getApplicationContext());
return sInstance;
}
public ChapterDbHelper(Context context) {
super(context, DB_NAME, null, VERSION);
}
@Override
public void onCreate(SQLiteDatabase db) {
//创建Chapter表
db.execSQL("create table if not exists " + Chapter.TABLE_NAME +
"(" +
Chapter.COL_ID + " integer primary key ," +
Chapter.COL_NAME + " varchar )");
//创建ChapterItem表
db.execSQL("create table if not exists " + ChapterItem.TABLE_NAME +
"(" +
ChapterItem.COL_ID + " integer primary key ," +
ChapterItem.COL_NAME + " varchar," +
ChapterItem.COL_PID + " integer " +
")");
}
//版本更新
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
}
}
ChapterDao.java
外公布数据库的操作
一个是从数据库加载数据(从缓存中拿数据)loadFromDb()
一个是将网络的数据插入到数据库中(放进缓存)insert2Db()
package com.demo.expandablelistviewdemo.dao;
import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.util.Log;
import com.demo.expandablelistviewdemo.bean.Chapter;
import com.demo.expandablelistviewdemo.bean.ChapterItem;
import java.util.ArrayList;
import java.util.List;
/**
* 对外公布数据库的操作
*/
public class ChapterDao {
//从数据库读取数据，转换成List返回
public List<Chapter> loadFromDb(Context context) {
ChapterDbHelper dbHelper = ChapterDbHelper.getsInstance(context);
//拿到读写数据库的对象
SQLiteDatabase db = dbHelper.getWritableDatabase();
//1.query Chapter的表
List<Chapter> chapterList = new ArrayList<>();
Cursor cursor = db.rawQuery("select*from " + Chapter.TABLE_NAME, null);
Chapter chapter = null;
while (cursor.moveToNext()) {
//每次遍历生成Chapter对象
chapter = new Chapter();
//拿数据
int id = cursor.getInt(cursor.getColumnIndex(Chapter.COL_ID));
String name = cursor.getString(cursor.getColumnIndex(Chapter.COL_NAME));
chapter.setId(id);
chapter.setName(name);
chapterList.add(chapter);
}
cursor.close();
//2.query chapterItems的表
ChapterItem chapterItem = null;
//遍历上面的结果，拿到pid，因为每一个chapterItem都有对应的pid
for (Chapter parent : chapterList) {
int pid = parent.getId();
Log.e("TAG", "pid=" + pid + "");
//每次查询出与当前pid相同的chapterItem
cursor = db.rawQuery("select* from " + ChapterItem.TABLE_NAME +
" where " + ChapterItem.COL_PID + "= ?",
new String[]{pid + ""});
Log.e("TAG", "cursor1=" + cursor + "");
while (cursor.moveToNext()) {
chapterItem = new ChapterItem();
//拿数据
int id = cursor.getInt(cursor.getColumnIndex(ChapterItem.COL_ID));
String name = cursor.getString(cursor.getColumnIndex(ChapterItem.COL_NAME));
chapterItem.setId(id);
chapterItem.setName(name);
chapterItem.setPid(pid);
parent.addChild(chapterItem);
}
cursor.close();
}
return chapterList;
}
//缓存数据到db
public void insert2Db(Context context, List<Chapter> chapterList) {
if (context == null)
throw new IllegalArgumentException("context can not be empty ");
if (chapterList == null || chapterList.isEmpty()) {
return;
}
//拿到ChapterDbHelper的单例对象
ChapterDbHelper dbHelper = ChapterDbHelper.getsInstance(context);
//写人数据
/**getReadableDatabase和getWritableDatabase的区别
* 1.两个方法都是返回读写数据库的对象，但是当磁盘已经满了时，getWritableDatabase会抛异常，
* 而getReadableDatabase不会报错，它此时不会返回读写数据库的对象，而是仅仅返回一个读数据库的对象。
* 2.getReadableDatabase会在问题修复后继续返回一个读写的数据库对象。
* 3.两者都是数据库操作，可能存在延迟等待，所以尽量不要在主线程中调用。
*/
//拿到读写数据库的对象
SQLiteDatabase db = dbHelper.getWritableDatabase();
//开始事务
db.beginTransaction();
//数据库存储 利用ContentValues
ContentValues contentValues = null;
//遍历传入的数据
for (Chapter chapter : chapterList) {
//1将数据通Chapter封装
contentValues = new ContentValues();
contentValues.put(Chapter.COL_ID, chapter.getId());
contentValues.put(Chapter.COL_NAME, chapter.getName());
//如果有冲突 如果相同的id name更新了，一般是不能插入，利用这个插入可以解决这个冲突
db.insertWithOnConflict(Chapter.TABLE_NAME,
null,
contentValues,
SQLiteDatabase.CONFLICT_REPLACE);
//每一个父Chapter下都有孩子
List<ChapterItem> children = chapter.getChildren();
//2.ChapterItem的数据封装
for (ChapterItem chapterItem : children) {
contentValues = new ContentValues();
contentValues.put(ChapterItem.COL_ID, chapterItem.getId());
contentValues.put(ChapterItem.COL_NAME, chapterItem.getName());
contentValues.put(ChapterItem.COL_PID, chapter.getId());
db.insertWithOnConflict(ChapterItem.TABLE_NAME,
null,
contentValues,
SQLiteDatabase.CONFLICT_REPLACE);
}
}
db.setTransactionSuccessful();
//关闭事务
db.endTransaction();
}
}
4.Utils工具类
HttpUtils.java
从网络上下载数据的工具类
记得在AndroidManifest.xml 申请网络权限
<uses-permission android:name="android.permission.INTERNET"/>
package com.demo.expandablelistviewdemo.utils;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;
/**
* 网络下载的工具类
*/
public class HttpUtils {
private static final int timeout = 5000;
private static InputStream is=null;
private static ByteArrayOutputStream baos=null;
private static HttpURLConnection conn;
public static String doGet(String urlStr) {
try {
URL url = new URL(urlStr);
conn = (HttpURLConnection) url.openConnection();
conn.setReadTimeout(timeout);
conn.setConnectTimeout(timeout);
conn.setRequestMethod("GET");
conn.setRequestProperty("accept", "*/*");
conn.setRequestProperty("connection", "Keep-Alive");
if (conn.getResponseCode() == 200) {
is = conn.getInputStream();
baos = new ByteArrayOutputStream();
int len = -1;
byte[] buf = new byte[512];
while ((len = is.read(buf)) != -1) {
baos.write(buf, 0, len);
}
baos.flush();
return baos.toString();
}
} catch (MalformedURLException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
finally {
//关闭流操作
if(baos!=null){
try {
baos.close();
} catch (IOException e) {
e.printStackTrace();
}
if (is!=null){
try {
is.close();
} catch (IOException e) {
e.printStackTrace();
}
}
conn.disconnect();
}
}
//发现异常，返回null
return null;
}
}
5.Biz业务逻辑层
实现数据显示的逻辑、和网络数据的解析
package com.demo.expandablelistviewdemo.biz;
import android.content.Context;
import android.os.AsyncTask;
import android.util.Log;
import com.demo.expandablelistviewdemo.bean.Chapter;
import com.demo.expandablelistviewdemo.bean.ChapterItem;
import com.demo.expandablelistviewdemo.dao.ChapterDao;
import com.demo.expandablelistviewdemo.utils.HttpUtils;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import java.util.ArrayList;
import java.util.List;
/**
* 业务逻辑层
*/
public class ChapterBiz {
private ChapterDao mChapterDao = new ChapterDao();
public void loadDatas(final Context context, final CallBack callBack, boolean useCache) {
AsyncTask<Boolean, Void, List<Chapter>> asyncTask = new AsyncTask<Boolean, Void, List<Chapter>>() {
private Exception ex;
//后台线程,进行下载操作
@Override
protected List<Chapter> doInBackground(Boolean... booleans) {
//拿到入参就是第一个 参数
boolean isUseCache = booleans[0];
//返回
List<Chapter> chapterList = new ArrayList<>();
try {
//判断是否要从缓存中拿数据
if (isUseCache) {
// load data from db
List<Chapter> chapterListFromDb = mChapterDao.loadFromDb(context);
Log.e("TAG", "chapterListFromDb=" + chapterListFromDb);
chapterList.addAll(chapterListFromDb);
}
//如果chapterList为空则缓存中没有数据，则进行网络下载
//load from net
if (chapterList.isEmpty()) {
//load from net
List<Chapter> chapterListFromNet = loadFromNet(context);
//cache to db
//从网络下载数据后将数据插入数据库
mChapterDao.insert2Db(context, chapterListFromNet);
chapterList.addAll(chapterListFromNet);
}
} catch (Exception ex) {
ex.printStackTrace();
this.ex = ex;
}
return chapterList;
}
//UI线程。通过传入的callBack返回结果到(MainActivity)UI线程
@Override
protected void onPostExecute(List<Chapter> chapters) {
super.onPostExecute(chapters);
if (ex != null) {//如果发生异常，将ex传出去(UI线程)
callBack.loadFailed(ex);
return;
}
//正常情况下，将我们下载后的数据传出去
callBack.loadSuccess(chapters);
}
};
asyncTask.execute(useCache);
}
//从网络上下载数据
//记得添加网络权限
private List<Chapter> loadFromNet(Context context) {
List<Chapter> chapterList = new ArrayList<>();
String url = "http://www.wanandroid.com/tools/mockapi/2/mooc-expandablelistview";
//1.发请求获取String数据
String content = HttpUtils.doGet(url);
Log.e("Tag", "content=" + content);
//2.content——>List<Chapter>
if (content != null) {
chapterList = parseContent(content);
Log.e("Tag", "parse finish chapterList=" + chapterList);
}
return chapterList;
}
//解析Json数据将从网络的数据转换成List<Chapter> 格式
private List<Chapter> parseContent(String content) {
List<Chapter> chapterList = new ArrayList<>();
try {
//最外层JSON
JSONObject root = new JSONObject(content);
//拿到erroCode get(没有数据会报异常) opt(没有数据返回null)
int errorCode = root.optInt("errorCode");
if (errorCode == 0) {
//拿data data是JsonArray
JSONArray datajsonArray = root.optJSONArray("data");
//遍历
for (int i = 0; i < datajsonArray.length(); i++) {
//第一层遍历得到Chapter对象 id /name
JSONObject chapterJsonObj = datajsonArray.getJSONObject(i);
int id = chapterJsonObj.optInt("id");
String name = chapterJsonObj.optString("name");
Chapter chapter = new Chapter(id, name);
chapterList.add(chapter);
//第二层解析 parse chapterItems children是一个数组
JSONArray childrenJsonArray = chapterJsonObj.optJSONArray("children");
if (childrenJsonArray != null) {
for (int j = 0; j < childrenJsonArray.length(); j++) {
JSONObject chapterItemJsonObj = childrenJsonArray.getJSONObject(j);
int cid = chapterItemJsonObj.optInt("id");
String cname = chapterItemJsonObj.optString("name");
ChapterItem chapterItem = new ChapterItem(cid, cname);
chapter.addChild(chapterItem);
}
}
}
}
} catch (JSONException e) {
e.printStackTrace();
}
return chapterList;
}
//通过CallBack返回数据到UI线程的接口
public static interface CallBack {
void loadSuccess(List<Chapter> chapterList);
void loadFailed(Exception ex);
}
}
6.UI界面及适配器
ChapterAdapter.java
package com.demo.expandablelistviewdemo.adapter;
import android.content.Context;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.BaseExpandableListAdapter;
import android.widget.ImageView;
import android.widget.TextView;
import com.demo.expandablelistviewdemo.R;
import com.demo.expandablelistviewdemo.bean.Chapter;
import java.util.List;
/**
* 适配器数据封装
*/
public class ChapterAdapter extends BaseExpandableListAdapter {
private Context context;//上下文
private List<Chapter> mData;//显示的数据
private LayoutInflater mInflater;
public ChapterAdapter(Context context,List<Chapter> mData) {
this.mData=mData;
this.context = context;
mInflater=LayoutInflater.from(context);
}
//父item的数目
@Override
public int getGroupCount() {
return mData.size();
}
//每一个父item下子item的数目
@Override
public int getChildrenCount(int groupPosition) {
return mData.get(groupPosition).getChildren().size();
}
//父item的位置
@Override
public Object getGroup(int groupPosition) {
return mData.get(groupPosition);
}
//每一个父item下子item的位置
@Override
public Object getChild(int groupPosition, int childPosition) {
return mData.get(groupPosition).getChildren().get(childPosition);
}
//父item的id
@Override
public long getGroupId(int groupPosition) {
return groupPosition;
}
@Override
public long getChildId(int groupPosition, int childPosition) {
return childPosition;
}
@Override
public boolean hasStableIds() {
return false;
}
//父item的布局设置
@Override
public View getGroupView(int groupPosition, boolean isExpanded, View convertView, ViewGroup parent) {
ParentViewHolder vh;
if(convertView==null){
vh =new ParentViewHolder();
convertView=mInflater.inflate(R.layout.item_parent_list,parent,false);
vh.parent_item_iv=convertView.findViewById(R.id.item_parent_iv);
vh.parent_item_tv=convertView.findViewById(R.id.item_parent_tv);
convertView.setTag(vh);
}
else{
vh= (ParentViewHolder) convertView.getTag();
}
vh.parent_item_tv.setText(mData.get(groupPosition).getName());
vh.parent_item_iv.setSelected(isExpanded);//是否为展开
vh.parent_item_iv.setImageResource(R.drawable.indicator_group);
return convertView;
}
//子item的布局设置
@Override
public View getChildView(int groupPosition, int childPosition, boolean isLastChild, View convertView, ViewGroup parent) {
ChildViewHolder vh;
if(convertView==null){
vh =new ChildViewHolder();
convertView=mInflater.inflate(R.layout.item_child_list,parent,false);
vh.chlid_item_tv=convertView.findViewById(R.id.item_child_tv);
convertView.setTag(vh);
}
else{
vh= (ChildViewHolder) convertView.getTag();
}
vh.chlid_item_tv.setText(mData.get(groupPosition).getChildren().get(childPosition).getName());
return convertView;
}
//控制child不可点击
@Override
public boolean isChildSelectable(int groupPosition, int childPosition) {
return true;
}
private static class ParentViewHolder{
ImageView parent_item_iv;
TextView parent_item_tv;
}
private static class ChildViewHolder{
TextView chlid_item_tv;
}
}
主界面
MainActivity.java
package com.demo.expandablelistviewdemo;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.ExpandableListView;
import com.demo.expandablelistviewdemo.adapter.ChapterAdapter;
import com.demo.expandablelistviewdemo.bean.Chapter;
import com.demo.expandablelistviewdemo.bean.ChapterLab;
import com.demo.expandablelistviewdemo.biz.ChapterBiz;
import java.util.ArrayList;
import java.util.List;
public class MainActivity extends AppCompatActivity {
private ExpandableListView expandableListView;
private ChapterAdapter madapter;
private List<Chapter> mDatas = new ArrayList<>();
private ChapterBiz mChapterBiz = new ChapterBiz();
private Button refresh_bt;//刷新按钮，将loadData()换成从数据库拿数据
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
expandableListView = findViewById(R.id.id_expandableLv);
refresh_bt = findViewById(R.id.id_btn_refresh);
//生成模拟数据
// mDatas= ChapterLab.generateDatas();
//拿到回调数据
//第一次打开从网络打开，设置为true
loadDatas(true);
madapter = new ChapterAdapter(this, mDatas);
expandableListView.setAdapter(madapter);
initEvents();//添加事件
}
//加载数据（拿到onPostExcuteUI线程回调的数据）
private void loadDatas(boolean useCache) {
mChapterBiz.loadDatas(this, new ChapterBiz.CallBack() {
@Override
public void loadSuccess(List<Chapter> chapterList) {
mDatas.clear();//每次都要清除一遍，否则会叠加
mDatas.addAll(chapterList);
madapter.notifyDataSetChanged();
}
@Override
public void loadFailed(Exception ex) {
}
}, useCache);
}
private void initEvents() {
//点击刷新按钮的监听，切换数据显示方式
refresh_bt.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
loadDatas(false);
}
});
//点击父item的监听
expandableListView.setOnGroupClickListener(new ExpandableListView.OnGroupClickListener() {
@Override
public boolean onGroupClick(ExpandableListView parent, View v, int groupPosition, long id) {
Log.e("TAG", "onGroupClick groupPosition" + groupPosition + " id=" + id);
return false;
}
});
//点击子item的监听
expandableListView.setOnChildClickListener(new ExpandableListView.OnChildClickListener() {
@Override
public boolean onChildClick(ExpandableListView parent, View v, int groupPosition, int childPosition, long id) {
Log.e("TAG", "onChildClick groupPosition" + groupPosition + " childPosition=" + childPosition + " id=" + id);
return false;
}
});
//点击父item收缩的监听
expandableListView.setOnGroupCollapseListener(new ExpandableListView.OnGroupCollapseListener() {
@Override
public void onGroupCollapse(int groupPosition) {
Log.e("TAG", "onGroupCollapse groupPosition=" + groupPosition);
}
});
//点击父item展开的监听
expandableListView.setOnGroupExpandListener(new ExpandableListView.OnGroupExpandListener() {
@Override
public void onGroupExpand(int groupPosition) {
Log.e("TAG", "onGroupExpand groupPosition=" + groupPosition);
}
});
}
}
615
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
