package cn.asiontang.nleveltreelistview;

 import android.annotation.TargetApi;

 import android.content.Context;

 import android.os.Build;

 import android.util.AttributeSet;

 import android.view.View;

 import android.widget.AdapterView;

 import android.widget.ListAdapter;

 import android.widget.ListView;

 /**

  * 支持N(无限)层级的树列表结构

  *

  * <p>参考资料：</p>

  * <ul>

  * <li>

  * <a href="http://item.congci.com/item/android-wuxian-ji-shuzhuang-jiegou">Android无限级树状结构 -

  * Android

  * - 从此网</a>

  * </li>

  * </ul>

  *

  * @author AsionTang

  * @since 2016年6月1日 18:38:43

  */

 @SuppressWarnings("unused")

 public class NLevelTreeView extends ListView

 {

     private OnTreeNodeClickListener mOnTreeNodeClickListener;

     public NLevelTreeView(final Context context)

     {

         super(context);

         this.init();

     }

     public NLevelTreeView(final Context context, final AttributeSet attrs)

     {

         super(context, attrs);

         this.init();

     }

     public NLevelTreeView(final Context context, final AttributeSet attrs, final int defStyleAttr)

     {

         super(context, attrs, defStyleAttr);

         this.init();

     }

     @TargetApi(Build.VERSION_CODES.LOLLIPOP)

     public NLevelTreeView(final Context context, final AttributeSet attrs, final int defStyleAttr, final int defStyleRes)

     {

         super(context, attrs, defStyleAttr, defStyleRes);

         this.init();

     }

     private void init()

     {

     }

     public void setAdapter(final NLevelTreeNodeAdapter adapter)

     {

         super.setAdapter(adapter);

         //让 NLevelTreeNodeAdapter 处理 节点 收缩展开 动作

         super.setOnItemClickListener(adapter);

         //处理当 叶子节点 被点击后的事件 回调。

         adapter.setOuterOnItemClickListener(new OnItemClickListener()

         {

             @Override

             public void onItemClick(final AdapterView<?> parent, final View view, final int position, final long id)

             {

                 if (NLevelTreeView.this.mOnTreeNodeClickListener != null)

                 {

                     final NLevelTreeNode item = (NLevelTreeNode) parent.getItemAtPosition(position);

                     NLevelTreeView.this.mOnTreeNodeClickListener.onTreeNodeClick(item);

                 }

             }

         });

     }

     /**

      * 必须使用继承自 NLevelTreeNodeAdapter 的 适配器，否则会出现异常。

      */

     @Override

     public void setAdapter(final ListAdapter adapter)

     {

         if (adapter instanceof NLevelTreeNodeAdapter)

             this.setAdapter((NLevelTreeNodeAdapter) adapter);

         else

             throw new RuntimeException("For NLevelTreeView, use setAdapter(NLevelTreeNodeAdapter) instead of setAdapter(ListAdapter)");

     }

     /**

      * 不支持使用此回调方式

      */

     @Override

     @Deprecated

     public void setOnItemClickListener(final OnItemClickListener listener)

     {

         //实际的事件回调在setAdapter里设置，由 setOnTreeNodeClickListener 处理。

         //super.setOuterOnItemClickListener(listener);

         throw new RuntimeException("For NLevelTreeView, use setOnTreeNodeClickListener() instead of setOnItemClickListener()");

     }

     /**

      * 默认只支持叶子节点的Click事件

      */

     public void setOnTreeNodeClickListener(final OnTreeNodeClickListener listener)

     {

         this.mOnTreeNodeClickListener = listener;

     }

     /**

      * 默认只支持叶子节点的Click事件

      */

     public interface OnTreeNodeClickListener

     {

         /**

          * 默认只支持叶子节点的Click事件

          */

         void onTreeNodeClick(NLevelTreeNode node);

     }

 }

 package cn.asiontang.nleveltreelistview;

 import android.content.Context;

 import android.view.View;

 import android.widget.AdapterView;

 import java.util.HashSet;

 import java.util.List;

 import java.util.Set;

 /**

  * @author AsionTang

  * @since 2016年6月1日 18:38:43

  */

 @SuppressWarnings("unused")

 public abstract class NLevelTreeNodeAdapter extends BaseAdapterEx3<NLevelTreeNode> implements AdapterView.OnItemClickListener

 {

     private final Set<NLevelTreeNode> mExpandedNodeList = new HashSet<>();

     private AdapterView.OnItemClickListener mOuterOnItemClickListener;

     public NLevelTreeNodeAdapter(final Context context, final int itemLayoutResId)

     {

         super(context, itemLayoutResId);

     }

     public NLevelTreeNodeAdapter(final Context context, final int itemLayoutResId, final List<NLevelTreeNode> objects)

     {

         super(context, itemLayoutResId, objects);

     }

     @Override

     public void convertView(final ViewHolder viewHolder, final NLevelTreeNode item)

     {

         this.convertView(viewHolder, item, this.mExpandedNodeList.contains(item));

     }

     public abstract void convertView(final ViewHolder viewHolder, final NLevelTreeNode item, boolean isExpanded);

     @Override

     public void onItemClick(final AdapterView<?> parent, final View view, final int position, final long id)

     {

         final NLevelTreeNode item = getItem(position);

         if (this.mExpandedNodeList.contains(item))

         {

             //把展开的节点，收缩起来

             this.mExpandedNodeList.remove(item);

             final int nextPosition = position + 1;

             while (true)

             {

                 //说明已经删除到最后一个节点了。

                 if (nextPosition >= this.getOriginaItems().size())

                     break;

                 final NLevelTreeNode tmpNode = this.getOriginaItems().get(nextPosition);

                 //只删除比它自己级别深的节点（如它的子、孙、重孙节点）

                 if (tmpNode.getLevel() <= item.getLevel())

                     break;

                 this.getOriginaItems().remove(tmpNode);

                 //防止它的子孙节点也有可能是展开的，所有也要移除其状态。

                 this.mExpandedNodeList.remove(tmpNode);

             }

             this.refresh();

         }

         else

         {

             //没有子节点，则不允许展开

             if (item.getChilds().size() == 0)

             {

                 //默认只支持叶子节点的Click事件

                 if (this.mOuterOnItemClickListener != null)

                     this.mOuterOnItemClickListener.onItemClick(parent, view, position, id);

                 return;

             }

             //把收缩的节点，展开起来

             this.mExpandedNodeList.add(item);

             this.getOriginaItems().addAll(position + 1, item.getChilds());

             this.refresh();

         }

     }

     /**

      * 设置外围调用者真正需要的 项点击OnItemClickListener 事件 回调。

      */

     protected void setOuterOnItemClickListener(final AdapterView.OnItemClickListener listener)

     {

         this.mOuterOnItemClickListener = listener;

     }

 }

 package cn.asiontang.nleveltreelistview;

 import java.util.ArrayList;

 import java.util.List;

 /**

  * @author AsionTang

  * @since 2016年6月1日 18:38:43

  */

 @SuppressWarnings("unused")

 public class NLevelTreeNode

 {

     private final List<NLevelTreeNode> mChilds = new ArrayList<>();

     private CharSequence mId;

     private int mLevel = 0;

     private CharSequence mName;

     private NLevelTreeNode mParentNode;

     public NLevelTreeNode()

     {

     }

     public NLevelTreeNode(final NLevelTreeNode parentNode, final int level, final CharSequence id, final CharSequence name)

     {

         this.setParentNode(parentNode);

         this.setLevel(level);

         this.setID(id);

         this.setName(name);

     }

     public NLevelTreeNode(final int level, final CharSequence id, final CharSequence name)

     {

         this(null, level, id, name);

     }

     public NLevelTreeNode(final CharSequence id, final CharSequence name)

     {

         this(null, 0, id, name);

     }

     public NLevelTreeNode(final CharSequence name)

     {

         this(null, 0, name, name);

     }

     /**

      * 为此Node添加一个子节点

      */

     public NLevelTreeNode addChild(final NLevelTreeNode child)

     {

         if (!this.mChilds.contains(child))

         {

             this.mChilds.add(child);

             child.setParentNode(this);

         }

         return this;

     }

     /**

      * 设置此Node所属的所有子节点

      */

     public NLevelTreeNode addChilds(final List<NLevelTreeNode> childs)

     {

         for (final NLevelTreeNode child : childs)

             this.addChild(child);

         return this;

     }

     /**

      * 获取此Node指定位置的子节点

      */

     public NLevelTreeNode getChild(final int index)

     {

         return this.mChilds.get(index);

     }

     /**

      * 获取此Node所属的所有子节点

      */

     public List<NLevelTreeNode> getChilds()

     {

         return this.mChilds;

     }

     /**

      * 获取当前Node 唯一标识符（当此Node被点击时，可供区分被点击的是谁）

      */

     public CharSequence getID()

     {

         return this.mId;

     }

     /**

      * 设置当前Node 唯一标识符（当此Node被点击时，可供区分被点击的是谁）

      */

     public NLevelTreeNode setID(final CharSequence id)

     {

         this.mId = id;

         return this;

     }

     /**

      * 获取当前Node所属哪个层级；一般从0级（根节点）开始递增。

      */

     public int getLevel()

     {

         return this.mLevel;

     }

     /**

      * 设置当前Node所在的层级；一般从0级（根节点）开始递增。

      */

     public NLevelTreeNode setLevel(final int level)

     {

         this.mLevel = level;

         //必须立即更新子节点的级别，否则就乱套了。

         for (final NLevelTreeNode child : this.mChilds)

             child.setLevel(level + 1);

         return this;

     }

     /**

      * 获取当前Node 名字

      */

     public CharSequence getName()

     {

         return this.mName;

     }

     /**

      * 设置当前Node 名字

      */

     public NLevelTreeNode setName(final CharSequence name)

     {

         this.mName = name;

         return this;

     }

     /**

      * 获取 此Note 的父节点

      */

     public NLevelTreeNode getParentNode()

     {

         return this.mParentNode;

     }

     /**

      * 设置 此Note 的父节点

      */

     public NLevelTreeNode setParentNode(final NLevelTreeNode parentNode)

     {

         this.mParentNode = parentNode;

         if (parentNode != null)

         {

             parentNode.addChild(this);

             this.setLevel(parentNode.getLevel() + 1);

         }

         return this;

     }

 }