Revision 8f139bfb
Added by Leszek Koltunski over 1 year ago
src/main/java/org/distorted/dialogs/RubikDialogPatternPagerAdapter.java | ||
---|---|---|
74 | 74 |
public void destroyItem(ViewGroup collection, int position, @NonNull Object view) |
75 | 75 |
{ |
76 | 76 |
collection.removeView((View) view); |
77 |
mViews[position] = null; |
|
77 | 78 |
} |
78 | 79 |
|
79 | 80 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
src/main/java/org/distorted/dialogs/RubikDialogScores.java | ||
---|---|---|
61 | 61 |
|
62 | 62 |
public void positiveAction() |
63 | 63 |
{ |
64 |
|
|
64 |
RubikDialogScoresThread thr = RubikDialogScoresThread.getInstance(); |
|
65 |
thr.exit(); |
|
65 | 66 |
} |
66 | 67 |
|
67 | 68 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
src/main/java/org/distorted/dialogs/RubikDialogScoresPagerAdapter.java | ||
---|---|---|
31 | 31 |
|
32 | 32 |
class RubikDialogScoresPagerAdapter extends PagerAdapter implements RubikNetwork.ScoresReceiver |
33 | 33 |
{ |
34 |
private static final int NETWORK_NOT_READY = 0; |
|
35 |
private static final int NETWORK_SUCCESS = 1; |
|
36 |
private static final int NETWORK_FAILURE = 2; |
|
37 |
|
|
34 | 38 |
private final FragmentActivity mAct; |
35 | 39 |
private final RubikDialogScores mDialog; |
36 | 40 |
private final RubikDialogScoresView[] mViews; |
37 | 41 |
private final ViewPager mViewPager; |
38 | 42 |
private final int mNumTabs; |
39 | 43 |
private final boolean mIsSubmitting; |
40 |
private int mToDoTab, mToDoLvl; |
|
41 |
|
|
42 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
43 |
|
|
44 |
private void prepareView() |
|
45 |
{ |
|
46 |
mAct.runOnUiThread(new Runnable() |
|
47 |
{ |
|
48 |
@Override |
|
49 |
public void run() |
|
50 |
{ |
|
51 |
for(int i=0; i<mNumTabs; i++) |
|
52 |
{ |
|
53 |
mViews[i].prepareView(mAct); |
|
54 |
} |
|
55 |
} |
|
56 |
}); |
|
57 |
try |
|
58 |
{ |
|
59 |
Thread.sleep(150); |
|
60 |
} |
|
61 |
catch( InterruptedException ignored) |
|
62 |
{ |
|
63 |
|
|
64 |
} |
|
65 |
} |
|
44 |
private final int[] mNumLevels; |
|
45 |
private String[][][] mCountry, mName; |
|
46 |
private int[][][] mTime; |
|
47 |
private String mMessage; |
|
48 |
private int mNetworkState; |
|
49 |
private final Object mObj; |
|
66 | 50 |
|
67 | 51 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
68 | 52 |
|
69 |
private void addSection(int tab, int level, int numLevels, final RubikDialogScoresView view, final String[] country, final String[] name, final int[] time)
|
|
53 |
public void receive(final String[][][] country, final String[][][] name, final int[][][] time)
|
|
70 | 54 |
{ |
71 |
String title = level==numLevels ? |
|
72 |
mAct.getString(R.string.levelM) : |
|
73 |
mAct.getString(R.string.lv_placeholder,level+1); |
|
74 |
|
|
75 |
final LinearLayout section = view.createSection(mAct, tab, title, level, country, name, time); |
|
76 |
|
|
77 |
mAct.runOnUiThread(new Runnable() |
|
78 |
{ |
|
79 |
@Override |
|
80 |
public void run() |
|
81 |
{ |
|
82 |
view.addSection(section); |
|
83 |
} |
|
84 |
}); |
|
85 |
|
|
86 |
try |
|
55 |
synchronized(mObj) |
|
87 | 56 |
{ |
88 |
Thread.sleep(50); |
|
89 |
} |
|
90 |
catch( InterruptedException ignored) |
|
91 |
{ |
|
92 |
|
|
93 |
} |
|
94 |
} |
|
57 |
RubikDialogScoresThread thr = RubikDialogScoresThread.getInstance(); |
|
58 |
thr.equip(mAct,mViewPager); |
|
95 | 59 |
|
96 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
60 |
mNetworkState = NETWORK_SUCCESS; |
|
61 |
mCountry = country; |
|
62 |
mName = name; |
|
63 |
mTime = time; |
|
97 | 64 |
|
98 |
private void getNext(int currentTab, int[] toDoTab, int[] numLevels) |
|
99 |
{ |
|
100 |
if( toDoTab[currentTab]<=numLevels[currentTab] ) |
|
101 |
{ |
|
102 |
mToDoTab = currentTab; |
|
103 |
mToDoLvl = toDoTab[currentTab]; |
|
104 |
toDoTab[currentTab]++; |
|
105 |
} |
|
106 |
else |
|
107 |
{ |
|
108 |
for(int tab=0; tab<mNumTabs; tab++) |
|
109 |
{ |
|
110 |
if( toDoTab[tab]<=numLevels[tab] ) |
|
65 |
for(int t=0; t<mNumTabs; t++) |
|
66 |
if( mViews[t]!=null ) |
|
111 | 67 |
{ |
112 |
mToDoTab = tab; |
|
113 |
mToDoLvl = toDoTab[tab]; |
|
114 |
toDoTab[tab]++; |
|
115 |
break; |
|
68 |
int num = mNumLevels[t]; |
|
69 |
String[][] c = country[t]; |
|
70 |
String[][] n = name[t]; |
|
71 |
int[][] tm = time[t]; |
|
72 |
for(int l=0; l<=num; l++) thr.newWork(t, l, num, mViews[t], c[l], n[l], tm[l]); |
|
116 | 73 |
} |
117 |
} |
|
118 |
} |
|
119 |
} |
|
120 |
|
|
121 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
122 |
|
|
123 |
public void receive(final String[][][] country, final String[][][] name, final int[][][] time) |
|
124 |
{ |
|
125 |
prepareView(); |
|
126 |
int toDo=0; |
|
127 |
int[] toDoTab = new int[mNumTabs]; |
|
128 |
int[] numLevels = new int[mNumTabs]; |
|
129 |
|
|
130 |
for(int i=0; i<mNumTabs; i++) |
|
131 |
{ |
|
132 |
toDoTab[i]= 0; |
|
133 |
RubikObject object = RubikObjectList.getObject(i); |
|
134 |
int numScramble = object==null ? 1 : object.getNumScramble(); |
|
135 |
numLevels[i] = Math.min(numScramble-1,RubikScreenPlay.LEVELS_SHOWN); |
|
136 |
toDo += (numLevels[i]+1); |
|
137 |
} |
|
138 |
|
|
139 |
while( toDo>0 ) |
|
140 |
{ |
|
141 |
toDo--; |
|
142 |
getNext(mViewPager.getCurrentItem(), toDoTab, numLevels); |
|
143 |
addSection( mToDoTab, mToDoLvl, numLevels[mToDoTab], mViews[mToDoTab], country[mToDoTab][mToDoLvl], name[mToDoTab][mToDoLvl], time[mToDoTab][mToDoLvl]); |
|
144 | 74 |
} |
145 | 75 |
} |
146 | 76 |
|
... | ... | |
148 | 78 |
|
149 | 79 |
public void message(final String mess) |
150 | 80 |
{ |
81 |
mNetworkState = NETWORK_FAILURE; |
|
82 |
mMessage = mess; |
|
83 |
|
|
151 | 84 |
mAct.runOnUiThread(new Runnable() |
152 | 85 |
{ |
153 | 86 |
@Override |
154 | 87 |
public void run() |
155 | 88 |
{ |
156 |
for(int i=0; i<mNumTabs; i++) mViews[i].message(mess); |
|
89 |
for(int i=0; i<mNumTabs; i++) |
|
90 |
if( mViews[i]!=null ) mViews[i].message(mess); |
|
157 | 91 |
} |
158 | 92 |
}); |
159 | 93 |
} |
... | ... | |
189 | 123 |
|
190 | 124 |
RubikDialogScoresPagerAdapter(FragmentActivity act, ViewPager viewPager, boolean isSubmitting, RubikDialogScores diag) |
191 | 125 |
{ |
126 |
mObj = new Object(); |
|
192 | 127 |
mAct = act; |
193 | 128 |
mDialog = diag; |
194 | 129 |
mNumTabs = RubikObjectList.getNumObjects(); |
195 | 130 |
mViews = new RubikDialogScoresView[mNumTabs]; |
196 | 131 |
mViewPager = viewPager; |
197 | 132 |
mIsSubmitting = isSubmitting; |
133 |
mNetworkState = NETWORK_NOT_READY; |
|
134 |
|
|
135 |
mNumLevels = new int[mNumTabs]; |
|
136 |
|
|
137 |
for(int i=0; i<mNumTabs; i++) |
|
138 |
{ |
|
139 |
RubikObject object = RubikObjectList.getObject(i); |
|
140 |
int numScramble = object==null ? 1 : object.getNumScramble(); |
|
141 |
mNumLevels[i] = Math.min(numScramble-1, RubikScreenPlay.LEVELS_SHOWN); |
|
142 |
} |
|
198 | 143 |
|
199 | 144 |
viewPager.setAdapter(this); |
200 |
viewPager.setOffscreenPageLimit(mNumTabs-1); |
|
145 |
viewPager.setOffscreenPageLimit(1); |
|
146 |
|
|
147 |
RubikNetwork network = RubikNetwork.getInstance(); |
|
148 |
|
|
149 |
if( mIsSubmitting ) network.submit ( this, mAct ); |
|
150 |
else network.download( this, mAct ); |
|
201 | 151 |
} |
202 | 152 |
|
203 | 153 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
... | ... | |
206 | 156 |
@NonNull |
207 | 157 |
public Object instantiateItem(@NonNull ViewGroup collection, int position) |
208 | 158 |
{ |
159 |
RubikDialogScoresView view; |
|
209 | 160 |
DisplayMetrics metrics = mAct.getResources().getDisplayMetrics(); |
210 | 161 |
|
211 |
mViews[position] = new RubikDialogScoresView(mAct, metrics.heightPixels, mIsSubmitting); |
|
212 |
collection.addView(mViews[position]); |
|
162 |
synchronized(mObj) |
|
163 |
{ |
|
164 |
view = new RubikDialogScoresView(mAct, metrics.heightPixels, mIsSubmitting); |
|
165 |
collection.addView(view); |
|
213 | 166 |
|
214 |
boolean allCreated = true; |
|
167 |
if( mNetworkState==NETWORK_SUCCESS ) |
|
168 |
{ |
|
169 |
int num = mNumLevels[position]; |
|
170 |
String[][] c = mCountry[position]; |
|
171 |
String[][] n = mName[position]; |
|
172 |
int[][] tm = mTime[position]; |
|
215 | 173 |
|
216 |
for(int i=0; i<mNumTabs; i++) |
|
217 |
{ |
|
218 |
if( mViews[i]==null ) |
|
174 |
for(int l=0; l<=num; l++) |
|
175 |
{ |
|
176 |
String title = (l==num ? mAct.getString(R.string.levelM) : mAct.getString(R.string.lv_placeholder, l+1)); |
|
177 |
LinearLayout section = view.createSection(mAct, position, title, l, c[l], n[l], tm[l]); |
|
178 |
view.addSection(mAct,section); |
|
179 |
} |
|
180 |
} |
|
181 |
else if( mNetworkState==NETWORK_FAILURE ) |
|
219 | 182 |
{ |
220 |
allCreated = false; |
|
221 |
break; |
|
183 |
view.message(mMessage); |
|
222 | 184 |
} |
223 | 185 |
} |
224 | 186 |
|
225 |
if( allCreated ) |
|
226 |
{ |
|
227 |
RubikNetwork network = RubikNetwork.getInstance(); |
|
228 |
|
|
229 |
if( mIsSubmitting ) network.submit ( this, mAct ); |
|
230 |
else network.download( this, mAct ); |
|
231 |
} |
|
187 |
mViews[position] = view; |
|
232 | 188 |
|
233 |
return mViews[position];
|
|
189 |
return view;
|
|
234 | 190 |
} |
235 | 191 |
|
236 | 192 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
... | ... | |
239 | 195 |
public void destroyItem(ViewGroup collection, int position, @NonNull Object view) |
240 | 196 |
{ |
241 | 197 |
collection.removeView((View) view); |
198 |
mViews[position] = null; |
|
242 | 199 |
} |
243 | 200 |
|
244 | 201 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
src/main/java/org/distorted/dialogs/RubikDialogScoresThread.java | ||
---|---|---|
1 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
2 |
// Copyright 2023 Leszek Koltunski // |
|
3 |
// // |
|
4 |
// This file is part of Distorted. // |
|
5 |
// // |
|
6 |
// Magic Cube is proprietary software licensed under an EULA which you should have received // |
|
7 |
// along with the code. If not, check https://distorted.org/magic/License-Magic-Cube.html // |
|
8 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
9 |
|
|
10 |
package org.distorted.dialogs; |
|
11 |
|
|
12 |
import android.widget.LinearLayout; |
|
13 |
|
|
14 |
import androidx.fragment.app.FragmentActivity; |
|
15 |
import androidx.viewpager.widget.ViewPager; |
|
16 |
|
|
17 |
import org.distorted.main.R; |
|
18 |
|
|
19 |
import java.lang.ref.WeakReference; |
|
20 |
import java.util.Vector; |
|
21 |
|
|
22 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
23 |
|
|
24 |
class RubikDialogScoresThread extends Thread |
|
25 |
{ |
|
26 |
private final Object mObject; |
|
27 |
private final Vector<WorkLoad> mBuffers; |
|
28 |
private WeakReference<FragmentActivity> mWeakAct; |
|
29 |
private ViewPager mViewPager; |
|
30 |
private boolean mRunning; |
|
31 |
|
|
32 |
private static RubikDialogScoresThread mThis; |
|
33 |
|
|
34 |
private static class WorkLoad |
|
35 |
{ |
|
36 |
int tab, level, numLevels; |
|
37 |
RubikDialogScoresView view; |
|
38 |
String[] country, name; |
|
39 |
int[] time; |
|
40 |
|
|
41 |
WorkLoad(int t, int l, int nl, RubikDialogScoresView v, String[] c, String[] n, int[] tm) |
|
42 |
{ |
|
43 |
tab = t; |
|
44 |
level = l; |
|
45 |
numLevels = nl; |
|
46 |
view = v; |
|
47 |
country = c; |
|
48 |
name = n; |
|
49 |
time = tm; |
|
50 |
} |
|
51 |
} |
|
52 |
|
|
53 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
54 |
|
|
55 |
private RubikDialogScoresThread() |
|
56 |
{ |
|
57 |
mObject = new Object(); |
|
58 |
mRunning = true; |
|
59 |
mBuffers = new Vector<>(); |
|
60 |
this.start(); |
|
61 |
} |
|
62 |
|
|
63 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
64 |
|
|
65 |
static RubikDialogScoresThread getInstance() |
|
66 |
{ |
|
67 |
if( mThis==null ) mThis = new RubikDialogScoresThread(); |
|
68 |
return mThis; |
|
69 |
} |
|
70 |
|
|
71 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
72 |
|
|
73 |
void equip(FragmentActivity act, ViewPager pager) |
|
74 |
{ |
|
75 |
mWeakAct = new WeakReference<>(act); |
|
76 |
mViewPager = pager; |
|
77 |
} |
|
78 |
|
|
79 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
80 |
|
|
81 |
void newWork(int t, int l, int nl, RubikDialogScoresView v, String[] c, String[] n, int[] tm) |
|
82 |
{ |
|
83 |
synchronized(mObject) |
|
84 |
{ |
|
85 |
WorkLoad load = new WorkLoad(t,l,nl,v,c,n,tm); |
|
86 |
mBuffers.add(load); |
|
87 |
mObject.notify(); |
|
88 |
} |
|
89 |
} |
|
90 |
|
|
91 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
92 |
|
|
93 |
void exit() |
|
94 |
{ |
|
95 |
synchronized(mObject) |
|
96 |
{ |
|
97 |
mRunning = false; |
|
98 |
mThis = null; |
|
99 |
mObject.notify(); |
|
100 |
} |
|
101 |
} |
|
102 |
|
|
103 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
104 |
|
|
105 |
public void run() |
|
106 |
{ |
|
107 |
WorkLoad load; |
|
108 |
|
|
109 |
while(true) |
|
110 |
{ |
|
111 |
synchronized(mObject) |
|
112 |
{ |
|
113 |
do |
|
114 |
{ |
|
115 |
load = getNextLoad(); |
|
116 |
if( load!=null ) process(load); |
|
117 |
} |
|
118 |
while(load!=null); |
|
119 |
|
|
120 |
if( mRunning ) |
|
121 |
{ |
|
122 |
try { mObject.wait(); } |
|
123 |
catch(InterruptedException ignored) { } |
|
124 |
} |
|
125 |
else break; |
|
126 |
} |
|
127 |
} |
|
128 |
} |
|
129 |
|
|
130 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
131 |
|
|
132 |
private WorkLoad getNextLoad() |
|
133 |
{ |
|
134 |
if( mViewPager==null ) return null; |
|
135 |
|
|
136 |
int currentTab = mViewPager.getCurrentItem(); |
|
137 |
int size = mBuffers.size(); |
|
138 |
|
|
139 |
for(int i=0; i<size; i++) |
|
140 |
{ |
|
141 |
WorkLoad load = mBuffers.get(i); |
|
142 |
if( load.tab==currentTab ) return mBuffers.remove(i); |
|
143 |
} |
|
144 |
|
|
145 |
return size>0 ? mBuffers.remove(0) : null; |
|
146 |
} |
|
147 |
|
|
148 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
149 |
|
|
150 |
private void process(WorkLoad load) |
|
151 |
{ |
|
152 |
final FragmentActivity act = mWeakAct.get(); |
|
153 |
int tab = load.tab; |
|
154 |
int level = load.level; |
|
155 |
int numLevels = load.numLevels; |
|
156 |
RubikDialogScoresView view = load.view; |
|
157 |
String[] country = load.country; |
|
158 |
String[] name = load.name; |
|
159 |
int[] time = load.time; |
|
160 |
String title = level==numLevels ? act.getString(R.string.levelM) : act.getString(R.string.lv_placeholder, level+1); |
|
161 |
|
|
162 |
final LinearLayout section = view.createSection(act, tab, title, level, country, name, time); |
|
163 |
|
|
164 |
act.runOnUiThread(new Runnable() |
|
165 |
{ |
|
166 |
@Override |
|
167 |
public void run() |
|
168 |
{ |
|
169 |
view.addSection(act,section); |
|
170 |
} |
|
171 |
}); |
|
172 |
} |
|
173 |
} |
src/main/java/org/distorted/dialogs/RubikDialogScoresView.java | ||
---|---|---|
30 | 30 |
|
31 | 31 |
public class RubikDialogScoresView extends FrameLayout |
32 | 32 |
{ |
33 |
private LinearLayout mLayout; |
|
33 |
private LinearLayout mLayout=null;
|
|
34 | 34 |
private int mHeight; |
35 | 35 |
|
36 | 36 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
... | ... | |
163 | 163 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
164 | 164 |
// needs to run on UI thread |
165 | 165 |
|
166 |
void prepareView(FragmentActivity act)
|
|
166 |
void addSection(FragmentActivity act, LinearLayout section)
|
|
167 | 167 |
{ |
168 |
removeAllViews(); |
|
169 |
|
|
170 |
View tab = inflate(act, R.layout.dialog_scores_tab, null); |
|
171 |
mLayout = tab.findViewById(R.id.tabLayout); |
|
172 |
addView(tab); |
|
173 |
} |
|
174 |
|
|
175 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
176 |
// needs to run on UI thread |
|
168 |
if( mLayout==null ) |
|
169 |
{ |
|
170 |
removeAllViews(); |
|
171 |
View tab = inflate(act, R.layout.dialog_scores_tab, null); |
|
172 |
mLayout = tab.findViewById(R.id.tabLayout); |
|
173 |
addView(tab); |
|
174 |
} |
|
177 | 175 |
|
178 |
void addSection(LinearLayout section) |
|
179 |
{ |
|
180 | 176 |
mLayout.addView(section); |
181 | 177 |
} |
182 | 178 |
|
src/main/java/org/distorted/dialogs/RubikDialogTutorialPagerAdapter.java | ||
---|---|---|
73 | 73 |
public void destroyItem(ViewGroup collection, int position, @NonNull Object view) |
74 | 74 |
{ |
75 | 75 |
collection.removeView((View) view); |
76 |
mViews[position] = null; |
|
76 | 77 |
} |
77 | 78 |
|
78 | 79 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
Also available in: Unified diff
- some progress with Mosaic Cube.
- very important memory optimizations for the main dialogs (mainly Scores - which no longer leaks memory!)
- increase the size of object icons from 144x144 to 256x256