111

hxb

2022-11-24 0a3e07f10937484145f33c7560607b4b2353cb81

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
package com.mm.android.deviceaddmodule.mobilecommon.widget.antistatic.spinnerwheel;
 
import android.view.View;
import android.widget.LinearLayout;
 
import java.util.LinkedList;
import java.util.List;
 
/**
 * Recycle stored spinnerwheel items to reuse.
 */
public class WheelRecycler {
 
 
    @SuppressWarnings("unused")
    private static final String LOG_TAG = WheelRecycler.class.getName();
 
    // Cached items
    private List<View> items;
 
    // Cached empty items
    private List<View> emptyItems;
 
    // Wheel view
    private AbstractWheel wheel;
 
    /**
     * Constructor
     * @param wheel the spinnerwheel view
     */
    public WheelRecycler(AbstractWheel wheel) {
        this.wheel = wheel;
    }
 
    /**
     * Recycles items from specified layout.
     * There are saved only items not included to specified range.
     * All the cached items are removed from original layout.
     *
     * @param layout the layout containing items to be cached
     * @param firstItem the number of first item in layout
     * @param range the range of current spinnerwheel items
     * @return the new value of first item number
     */
    public int recycleItems(LinearLayout layout, int firstItem, ItemsRange range) {
        int index = firstItem;
        for (int i = 0; i < layout.getChildCount();) {
            if (!range.contains(index)) {
                recycleView(layout.getChildAt(i), index);
                layout.removeViewAt(i);
                if (i == 0) { // first item
                    firstItem++;
                }
            } else {
                i++; // go to next item
            }
            index++;
        }
        return firstItem;
    }
 
    /**
     * Gets item view
     * @return the cached view
     */
    public View getItem() {
        return getCachedView(items);
    }
 
    /**
     * Gets empty item view
     * @return the cached empty view
     */
    public View getEmptyItem() {
        return getCachedView(emptyItems);
    }
 
    /**
     * Clears all views
     */
    public void clearAll() {
        if (items != null) {
            items.clear();
        }
        if (emptyItems != null) {
            emptyItems.clear();
        }
    }
 
    /**
     * Adds view to specified cache. Creates a cache list if it is null.
     * @param view the view to be cached
     * @param cache the cache list
     * @return the cache list
     */
    private List<View> addView(View view, List<View> cache) {
        if (cache == null) {
            cache = new LinkedList<>();
        }
 
        cache.add(view);
        return cache;
    }
 
    /**
     * Adds view to cache. Determines view type (item view or empty one) by index.
     * @param view the view to be cached
     * @param index the index of view
     */
    private void recycleView(View view, int index) {
        int count = wheel.getViewAdapter().getItemsCount();
 
        if ((index < 0 || index >= count) && !wheel.isCyclic()) {
            // empty view
            emptyItems = addView(view, emptyItems);
        } else {
            while (index < 0) {
                index = count + index;
            }
            index %= count;
            items = addView(view, items);
        }
    }
 
    /**
     * Gets view from specified cache.
     * @param cache the cache
     * @return the first view from cache.
     */
    private View getCachedView(List<View> cache) {
        if (cache != null && cache.size() > 0) {
            View view = cache.get(0);
            cache.remove(0);
            return view;
        }
        return null;
    }
 
}