IM社交App03

阅读原文

创建邀请信息的数据库

群信息的 bean 对象

**
 * 群信息的bean类
 */
public class GroupInfo
{
    private String groupName;    // 群名称
    private String groupId;     // 群id
    private String invatePerson;// 邀请人

    public GroupInfo()
    {

    }

    public GroupInfo(String groupName, String groupId, String invatePerson)
    {
        this.groupName = groupName;
        this.groupId = groupId;
        this.invatePerson = invatePerson;
    }

    public String getGroupName()
    {
        return groupName;
    }

    public String getGroupId()
    {
        return groupId;
    }

    public String getInvatePerson()
    {
        return invatePerson;
    }

    public void setGroupName(String groupName)
    {
        this.groupName = groupName;
    }

    public void setGroupId(String groupId)
    {
        this.groupId = groupId;
    }

    public void setInvatePerson(String invatePerson)
    {
        this.invatePerson = invatePerson;
    }

    @Override
    public String toString()
    {
        return "GroupInfo{" +
                "groupName='" + groupName + '\'' +
                ", groupId='" + groupId + '\'' +
                ", invatePerson='" + invatePerson + '\'' +
                '}';
    }
}

邀请信息的 bean 对象

/**
 * 邀请信息的bean类
 */
public class InvationInfo
{
    private UserInfo user; // 联系人
    private GroupInfo group; // 群组
    private String raason;// 邀请原因
    private InvitationStatus status;// 邀请的状态

    public InvationInfo()
    {

    }

    public InvationInfo(UserInfo user, GroupInfo group, String raason, InvitationStatus status)
    {
        this.user = user;
        this.group = group;
        this.raason = raason;
        this.status = status;
    }

    public UserInfo getUser()
    {
        return user;
    }

    public GroupInfo getGroup()
    {
        return group;
    }

    public String getRaason()
    {
        return raason;
    }

    public InvitationStatus getStatus()
    {
        return status;
    }

    public void setUser(UserInfo user)
    {
        this.user = user;
    }

    public void setGroup(GroupInfo group)
    {
        this.group = group;
    }

    public void setRaason(String raason)
    {
        this.raason = raason;
    }

    public void setStatus(InvitationStatus status)
    {
        this.status = status;
    }

    public enum InvitationStatus
    {
        // 联系人邀请信息状态
        NEW_INVITE,// 新邀请
        INVITE_ACCEPT,//接受邀请
        INVITE_ACCEPT_BY_PEER,// 邀请被接受

        // --以下是群组邀请信息状态--

        //收到邀请去加入群
        NEW_GROUP_INVITE,

        //收到申请群加入
        NEW_GROUP_APPLICATION,

        //群邀请已经被对方接受
        GROUP_INVITE_ACCEPTED,

        //群申请已经被批准
        GROUP_APPLICATION_ACCEPTED,

        //接受了群邀请
        GROUP_ACCEPT_INVITE,

        //批准的群加入申请
        GROUP_ACCEPT_APPLICATION,

        //拒绝了群邀请
        GROUP_REJECT_INVITE,

        //拒绝了群申请加入
        GROUP_REJECT_APPLICATION,

        //群邀请被对方拒绝
        GROUP_INVITE_DECLINED,

        //群申请被拒绝
        GROUP_APPLICATION_DECLINED
    }

    @Override
    public String toString()
    {
        return "InvationInfo{" +
                "user=" + user +
                ", group=" + group +
                ", raason='" + raason + '\'' +
                ", status=" + status +
                '}';
    }
}

创建联系人数据库建表语句

/**
 * 邀请信息的表
 */
public class InviteTable
{
    public static final String TAB_NAME = "tab_invite";

    public static final String COL_USER_HXID = "user_hxid";// 用户的环信id
    public static final String COL_USER_NAME = "user_name";// 用户的名称

    public static final String COL_GROUP_NAME = "group_name";// 群组名称
    public static final String COL_GROUP_HXID = "group_hxid";// 群组环信id

    public static final String COL_REASON = "reason";// 邀请的原因
    public static final String COL_STATUS = "status";// 邀请的状态


    public static final String CREATE_TAB = "create table "
            + TAB_NAME + " ("
            + COL_USER_HXID + " text primary key,"
            + COL_USER_NAME + " text,"
            + COL_GROUP_HXID + " text,"
            + COL_GROUP_NAME + " text,"
            + COL_REASON + " text,"
            + COL_STATUS + " integer);";
}

获取所有邀请信息

/**
 * 邀请信息表的操作类
 */
public class InviteTableDao
{
    private DBHelper mHelper;

    /**
     * 构造器
     * @param helper
     */
    public InviteTableDao(DBHelper helper)
    {
        mHelper=helper;
    }

    /**
     * 添加邀请
     * @param invitationInfo
     */
    public void addInvitation(InvationInfo invitationInfo)
    {
        // 获取数据库链接
        SQLiteDatabase db = mHelper.getReadableDatabase();

        // 执行添加语句
        ContentValues values=new ContentValues();
        values.put(InviteTable.COL_REASON,invitationInfo.getRaason());// 原因
        values.put(InviteTable.COL_STATUS,invitationInfo.getStatus().ordinal());// 状态,枚举类型转integer

        UserInfo user=invitationInfo.getUser();

        if(user!=null)//联系人
        {
            values.put(InviteTable.COL_USER_HXID,invitationInfo.getUser().getHxid());
            values.put(InviteTable.COL_USER_NAME,invitationInfo.getUser().getName());
        }
        else// 群组
        {
            values.put(InviteTable.COL_GROUP_HXID,invitationInfo.getGroup().getGroupId());
            values.put(InviteTable.COL_GROUP_NAME,invitationInfo.getGroup().getGroupName());
            values.put(InviteTable.COL_USER_HXID, invitationInfo.getGroup().getInvatePerson());

        }
        //执行添加
        db.replace(InviteTable.TAB_NAME,null,values);

    }

    /**
     * 获取所有邀请信息
     * @return
     */
    public List<InvationInfo> getInvitations()
    {
        // 获取数据库链接
        SQLiteDatabase db=mHelper.getReadableDatabase();

        // 执行查询语句
        String sql="select * from " + InviteTable.TAB_NAME;//sql语句
        Cursor cursor=db.rawQuery(sql,null);

        //总邀请信息集合
        List<InvationInfo>invationInfos=new ArrayList<>();

        while(cursor.moveToNext())
        {
            //单次循环对象
            InvationInfo invationInfo=new InvationInfo();

            invationInfo.setRaason(cursor.getString(cursor.getColumnIndex(InviteTable.COL_REASON)));// 拿到原因列数据
            invationInfo.setStatus(int2InviteStatus(cursor.getInt(cursor.getColumnIndex(InviteTable.COL_STATUS))));// 拿到状态

            //通过群id来判断，实现群和联系人的信息区分，先获取群id
            String groupId=cursor.getString(cursor.getColumnIndex(InviteTable.COL_GROUP_HXID));

            if(groupId==null)// 如果群id为空，认为是联系人的邀请信息
            {

                UserInfo userInfo=new UserInfo();//new一个联系人

                //进一步封装
                userInfo.setHxid(cursor.getString(cursor.getColumnIndex(InviteTable.COL_USER_HXID)));
                userInfo.setName(cursor.getString(cursor.getColumnIndex(InviteTable.COL_USER_NAME)));
                userInfo.setNick(cursor.getString(cursor.getColumnIndex(InviteTable.COL_USER_NAME)));//昵称和用户名称一样

                invationInfo.setUser(userInfo);
            }
            else// 群组的邀请信息
            {

                GroupInfo groupInfo=new GroupInfo();//new一个 groupInfo

                //封装
                groupInfo.setGroupId(cursor.getString(cursor.getColumnIndex(InviteTable.COL_GROUP_HXID)));
                groupInfo.setGroupName(cursor.getString(cursor.getColumnIndex(InviteTable.COL_GROUP_NAME)));
                groupInfo.setInvatePerson(cursor.getString(cursor.getColumnIndex(InviteTable.COL_USER_HXID)));//存在邀请信息的时候。通过id来获取联系人信息

                invationInfo.setGroup(groupInfo);
            }
            // 添加本次循环的邀请信息到总的集合中
            invationInfos.add(invationInfo);
        }
        // 关闭资源
        cursor.close();

        // 返回数据
        return invationInfos;
    }


    /**
     * 将int类型状态转换为邀请的状态
     * @param intStatus
     * @return
     */
    private InvationInfo.InvitationStatus int2InviteStatus(int intStatus)
    {
        if (intStatus == InvationInfo.InvitationStatus.NEW_INVITE.ordinal()) {
            return InvationInfo.InvitationStatus.NEW_INVITE;
        }

        if (intStatus == InvationInfo.InvitationStatus.INVITE_ACCEPT.ordinal()) {
            return InvationInfo.InvitationStatus.INVITE_ACCEPT;
        }

        if (intStatus == InvationInfo.InvitationStatus.INVITE_ACCEPT_BY_PEER.ordinal()) {
            return InvationInfo.InvitationStatus.INVITE_ACCEPT_BY_PEER;
        }

        if (intStatus == InvationInfo.InvitationStatus.NEW_GROUP_INVITE.ordinal()) {
            return InvationInfo.InvitationStatus.NEW_GROUP_INVITE;
        }

        if (intStatus == InvationInfo.InvitationStatus.NEW_GROUP_APPLICATION.ordinal()) {
            return InvationInfo.InvitationStatus.NEW_GROUP_APPLICATION;
        }

        if (intStatus == InvationInfo.InvitationStatus.GROUP_INVITE_ACCEPTED.ordinal()) {
            return InvationInfo.InvitationStatus.GROUP_INVITE_ACCEPTED;
        }

        if (intStatus == InvationInfo.InvitationStatus.GROUP_APPLICATION_ACCEPTED.ordinal()) {
            return InvationInfo.InvitationStatus.GROUP_APPLICATION_ACCEPTED;
        }

        if (intStatus == InvationInfo.InvitationStatus.GROUP_INVITE_DECLINED.ordinal()) {
            return InvationInfo.InvitationStatus.GROUP_INVITE_DECLINED;
        }

        if (intStatus == InvationInfo.InvitationStatus.GROUP_APPLICATION_DECLINED.ordinal()) {
            return InvationInfo.InvitationStatus.GROUP_APPLICATION_DECLINED;
        }

        if (intStatus == InvationInfo.InvitationStatus.GROUP_ACCEPT_INVITE.ordinal()) {
            return InvationInfo.InvitationStatus.GROUP_ACCEPT_INVITE;
        }

        if (intStatus == InvationInfo.InvitationStatus.GROUP_ACCEPT_APPLICATION.ordinal()) {
            return InvationInfo.InvitationStatus.GROUP_ACCEPT_APPLICATION;
        }

        if (intStatus == InvationInfo.InvitationStatus.GROUP_REJECT_APPLICATION.ordinal()) {
            return InvationInfo.InvitationStatus.GROUP_REJECT_APPLICATION;
        }

        if (intStatus == InvationInfo.InvitationStatus.GROUP_REJECT_INVITE.ordinal()) {
            return InvationInfo.InvitationStatus.GROUP_REJECT_INVITE;
        }

        return null;
    }

    /**
     * 删除邀请
     * @param hxId
     */
    public void removeInvitation(String hxId)
    {
        if(hxId==null)//为空的话就没必要删除了
        {
            return;
        }

        /**
         * 如果不为空
         */
        // 获取数据库链接
        SQLiteDatabase db=mHelper.getReadableDatabase();

        // 执行删除语句，根据Hxid去删除
        db.delete(InviteTable.TAB_NAME,InviteTable.COL_USER_HXID + "=?",new String[]{hxId});
    }

    /**
     * 更新邀请状态
     * @param invitationStatus
     * @param hxId
     */
    public void updateInvitationStatus(InvationInfo.InvitationStatus invitationStatus, String hxId)
    {
        if(hxId==null)
        {
            return;
        }
        // 获取数据库链接
        SQLiteDatabase db = mHelper.getReadableDatabase();

        // 执行更新操作
        ContentValues values=new ContentValues();
        values.put(InviteTable.COL_STATUS,invitationStatus.ordinal());

        //根据HXid，如果当前id等于传进来的id，就被修改该条数据
        db.update(InviteTable.TAB_NAME,values,InviteTable.COL_USER_HXID + "=?",new String[]{hxId});
    }
}

3.7 功能七:邀请页面

页面布局

<?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:layout_width="match_parent"
              android:layout_height="match_parent"
              xmlns:app="http://schemas.android.com/apk/res-auto"
              android:orientation="vertical">

    <com.hyphenate.easeui.widget.EaseTitleBar
        app:titleBarTitle="邀请信息列表页面"
        android:layout_width="match_parent"
        android:layout_height="wrap_content">

    </com.hyphenate.easeui.widget.EaseTitleBar>

    <ListView
        android:id="@+id/lv_invite"
        android:layout_width="match_parent"
        android:layout_height="match_parent">

    </ListView>
</LinearLayout>

Lisview 适配器

**
 * 邀请信息列表页面的适配器
 */
public class InviteAdapter extends BaseAdapter
{
    private Context mContext;
    private List<InvationInfo>mInvitationInfos=new ArrayList<>();
    private OnInviteListener mOnInviteListener;
    private InvationInfo invationInfo;

    /**
     * 构造器
     * @param context
     */
    public InviteAdapter(Context context,OnInviteListener onInviteListener)
    {
        mContext=context;
        mOnInviteListener=onInviteListener;
    }


    /**
     * 刷新数据的方法
     * @param invationInfos
     */
    public void refresh(List<InvationInfo>invationInfos)
    {
        if(invationInfos!=null && invationInfos.size()>=0)
        {
            mInvitationInfos.clear();

            mInvitationInfos.addAll(invationInfos);

            notifyDataSetChanged();
        }
    }
    @Override
    public int getCount()
    {
        return mInvitationInfos==null ? 0: mInvitationInfos.size();
    }

    @Override
    public Object getItem(int position)
    {
        return mInvitationInfos.get(position);
    }

    @Override
    public long getItemId(int position)
    {
        return position;
    }

    @Override
    public View getView(int position, View convertView, ViewGroup parent)
    {
        //1.获取或创建viewHolder
        ViewHodler hodler=null;
        if(convertView==null)
        {
            hodler=new ViewHodler();
            convertView=View.inflate(mContext, R.layout.item_invite,null);

            hodler.name=(TextView)convertView.findViewById(R.id.tv_invite_name);
            hodler.reason= (TextView) convertView.findViewById(R.id.tv_invite_reason);
            hodler.accept= (Button) convertView.findViewById(R.id.bt_invite_accept);
            hodler.reject= (Button) convertView.findViewById(R.id.bt_invite_reject);

            convertView.setTag(hodler);
        }
        else
        {
            hodler= (ViewHodler) convertView.getTag();
        }

        //2.获取当前item数据

        invationInfo=mInvitationInfos.get(position);

        //3.显示当前item数据
        UserInfo user=invationInfo.getUser();

        if(user!= null)// 联系人
        {
            // 名称的展示
            hodler.name.setText(user.getName());//拿到名次
            hodler.accept.setVisibility(View.GONE);
            hodler.reject.setVisibility(View.GONE);

            // 原因                                                  // 新的邀请
            if(invationInfo.getStatus()==InvationInfo.InvitationStatus.NEW_INVITE)
            {
                if(invationInfo.getRaason()==null)
                {
                    hodler.reason.setText("添加好友");
                }
                else
                {
                    hodler.reason.setText(invationInfo.getRaason());
                }
                hodler.accept.setVisibility(View.VISIBLE);
                hodler.reject.setVisibility(View.VISIBLE);

            }
            // 接受邀请
            else if(invationInfo.getStatus()==InvationInfo.InvitationStatus.INVITE_ACCEPT)
            {

                if(invationInfo.getRaason()==null)
                {
                    hodler.reason.setText("接受邀请");
                }
                else
                {
                    hodler.reason.setText(invationInfo.getRaason());
                }
            }
            // 邀请被接受
            else if(invationInfo.getStatus()==InvationInfo.InvitationStatus.INVITE_ACCEPT_BY_PEER)
            {
                hodler.accept.setVisibility(View.GONE);
                hodler.reject.setVisibility(View.GONE);

                if (invationInfo.getRaason() == null)
                {
                    hodler.reason.setText("邀请被接受");
                }
                else
                {
                    hodler.reason.setText(invationInfo.getRaason());
                }
            }
            // 按钮的处理
            hodler.accept.setOnClickListener(new View.OnClickListener()
            {
                @Override
                public void onClick(View v)
                {
                    mOnInviteListener.onAccept(invationInfo);
                }
            });

            // 拒绝按钮的点击事件处理
            hodler.reject.setOnClickListener(new View.OnClickListener()
            {
                @Override
                public void onClick(View v)
                {
                    mOnInviteListener.onReject(invationInfo);
                }
            });
        }
        // 群组
        else
        {
            // 显示名称
            hodler.name.setText(invationInfo.getGroup().getInvatePerson());

            hodler.accept.setVisibility(View.GONE);
            hodler.reject.setVisibility(View.GONE);

            // 显示原因
            switch (invationInfo.getStatus())
            {
                // 您的群申请请已经被接受
                case GROUP_APPLICATION_ACCEPTED:
                    hodler.reason.setText("您的群申请请已经被接受");
                    break;
                //  您的群邀请已经被接收
                case GROUP_INVITE_ACCEPTED:
                    hodler.reason.setText("您的群邀请已经被接收");
                    break;

                // 你的群申请已经被拒绝
                case GROUP_APPLICATION_DECLINED:
                    hodler.reason.setText("你的群申请已经被拒绝");
                    break;

                // 您的群邀请已经被拒绝
                case GROUP_INVITE_DECLINED:
                    hodler.reason.setText("您的群邀请已经被拒绝");
                    break;

                // 您收到了群邀请
                case NEW_GROUP_INVITE:
                    hodler.accept.setVisibility(View.VISIBLE);
                    hodler.reject.setVisibility(View.VISIBLE);

                    // 接受邀请
                    hodler.accept.setOnClickListener(new View.OnClickListener() {
                        @Override
                        public void onClick(View v) {
                            mOnInviteListener.onInviteAccept(invationInfo);
                        }
                    });

                    // 拒绝邀请
                    hodler.reject.setOnClickListener(new View.OnClickListener() {
                        @Override
                        public void onClick(View v) {
                            mOnInviteListener.onInviteReject(invationInfo);
                        }
                    });

                    hodler.reason.setText("您收到了群邀请");
                    break;

                // 您收到了群申请
                case NEW_GROUP_APPLICATION:
                    hodler.accept.setVisibility(View.VISIBLE);
                    hodler.reject.setVisibility(View.VISIBLE);

                    // 接受申请
                    hodler.accept.setOnClickListener(new View.OnClickListener() {
                        @Override
                        public void onClick(View v) {
                            mOnInviteListener.onApplicationAccept(invationInfo);
                        }
                    });

                    // 拒绝申请
                    hodler.reject.setOnClickListener(new View.OnClickListener() {
                        @Override
                        public void onClick(View v) {
                            mOnInviteListener.onApplicationReject(invationInfo);
                        }
                    });

                    hodler.reason.setText("您收到了群申请");
                    break;

                // 你接受了群邀请
                case GROUP_ACCEPT_INVITE:
                    hodler.reason.setText("你接受了群邀请");
                    break;

                // 您批准了群申请
                case GROUP_ACCEPT_APPLICATION:
                    hodler.reason.setText("您批准了群申请");
                    break;

                // 您拒绝了群邀请
                case GROUP_REJECT_INVITE:
                    hodler.reason.setText("您拒绝了群邀请");
                    break;

                // 您拒绝了群申请
                case GROUP_REJECT_APPLICATION:
                    hodler.reason.setText("您拒绝了群申请");
                    break;
            }
        }

        //4.返回view
        return convertView;
    }

    private class ViewHodler
    {
        private TextView name;
        private TextView reason;

        private Button accept;
        private Button reject;
    }

    public interface OnInviteListener
    {
        // 联系人接受按钮的点击事件
        void onAccept(InvationInfo invationInfo);

        // 联系人拒绝按钮的点击事件
        void onReject(InvationInfo invationInfo);

        // 接受邀请按钮处理
        void onInviteAccept(InvationInfo invationInfo);
        // 拒绝邀请按钮处理
        void onInviteReject(InvationInfo invationInfo);

        // 接受申请按钮处理
        void onApplicationAccept(InvationInfo invationInfo);
        // 拒绝申请按钮处理
        void onApplicationReject(InvationInfo invationInfo);
    }
}

3.8 功能八:会话详情页面

页面布局

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical" android:layout_width="match_parent"
android:layout_height="match_parent">
<FrameLayout
android:id="@+id/fragment_chat"
android:layout_width="wrap_content"
android:layout_height="wrap_content"/>
</LinearLayout>

创建环信提供的会话页面

/**
 * 会话列表页面
 */
public class ChatFragment extends EaseConversationListFragment
{
    @Override
    protected void initView()
    {
        super.initView();

        // 跳转到会话详情页面
        setConversationListItemClickListener(new EaseConversationListItemClickListener()
        {
            @Override
            public void onListItemClicked(EMConversation conversation)
            {
                Intent intent=new Intent(getActivity(), ChatActivity.class);

                // 传递参数
                intent.putExtra(EaseConstant.EXTRA_USER_ID,conversation.conversationId());

                // 是否是否群聊
                if(conversation.getType()==EMConversation.EMConversationType.GroupChat)
                {
                    intent.putExtra(EaseConstant.EXTRA_CHAT_TYPE,EaseConstant.CHATTYPE_GROUP);
                }
                startActivity(intent);
            }
        });

        // 请空集合数据(安卓5.0以下)
        conversationList.clear();

        // 监听会话消息
        EMClient.getInstance().chatManager().addMessageListener(emMessageListener);
    }

    private EMMessageListener emMessageListener=new EMMessageListener()
    {
        @Override
        public void onMessageReceived(List<EMMessage> list)
        {
            // 设置数据
            EaseUI.getInstance().getNotifier().onNewMesg(list);
            // 刷新页面
            refresh();
        }

        @Override
        public void onCmdMessageReceived(List<EMMessage> list)
        {

        }

        @Override
        public void onMessageReadAckReceived(List<EMMessage> list)
        {

        }

        @Override
        public void onMessageDeliveryAckReceived(List<EMMessage> list)
        {

        }

        @Override
        public void onMessageChanged(EMMessage emMessage, Object o)
        {

        }
    };
}

3.10 功能十:群列表页面

页面布局

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical" android:layout_width="match_parent"
android:layout_height="match_parent">
<com.hyphenate.easeui.widget.EaseTitleBar
android:layout_width="match_parent"
android:layout_height="wrap_content"
xmlns:app="http://schemas.android.com/apk/res-auto"
app:titleBarTitle="群组列表"/>
<ListView
android:id="@+id/lv_group_list"
android:layout_width="match_parent"
android:layout_height="wrap_content"/>
</LinearLayout>

Listview 添加头布局

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical" android:layout_width="match_parent"
android:layout_height="match_parent">
<LinearLayout
android:layout_width="match_parent"
android:layout_height="wrap_content">
<ImageView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:src="@drawable/em_create_group"/>
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:textSize="20sp"
android:paddingLeft="10dp"
android:layout_gravity="center"
android:text="创建群组"/>
</LinearLayout>
</LinearLayout>

Listview 适配器

/**
 * 群组列表的适配器
 */
public class GroupListAdapter extends BaseAdapter
{
    private Context mContext;
    private List<EMGroup>mGroups=new ArrayList<>();

    /**
     * 构造器
     * @param context
     */
    public GroupListAdapter(Context context)
    {
        mContext=context;
    }

    /**
     * 刷新方法
     * @param groups
     */
    public void refresh(List<EMGroup>groups)
    {
        if(groups!=null && groups.size()>=0)
        {
            mGroups.clear();
            mGroups.addAll(groups);
            notifyDataSetChanged();
        }
    }

    /**
     *
     * @return
     */
    @Override
    public int getCount()
    {
        return mGroups==null?0:mGroups.size();
    }

    @Override
    public Object getItem(int position)
    {
        return mGroups.get(position);
    }

    @Override
    public long getItemId(int position)
    {
        return position;
    }

    @Override
    public View getView(int position, View convertView, ViewGroup parent)
    {
        // 创建或获取viewholder
        ViewHolder holder=null;
        if(convertView==null)
        {
            holder=new ViewHolder();

            convertView=View.inflate(mContext, R.layout.item_grouplist,null);

            holder.name=(TextView)convertView.findViewById(R.id.tv_grouplist_name);

            convertView.setTag(holder);
        }
        else
        {
            holder=(ViewHolder)convertView.getTag();
        }

        //获取当前item数据
        EMGroup emGroup=mGroups.get(position);
        // 显示数据
        holder.name.setText(emGroup.getGroupName());
        // 返回数据
        return convertView;
    }

    private class ViewHolder
    {
        TextView name;
    }
}