make accessProtectedResource a method
[WhereAmI.git] / src / org / average / whereami / WhereAmI.java
1 package org.average.whereami;
2
3 import org.average.whereami.WhereAmIprefs;
4 import org.average.whereami.Oracle;
5 import org.average.whereami.PhoneLog;
6 import org.average.whereami.LastLocation;
7
8 import android.app.Activity;
9 import android.net.wifi.WifiManager;
10 import android.os.Build;
11 import android.os.Bundle;
12 import android.os.AsyncTask;
13 import android.os.Handler;
14 import android.net.ConnectivityManager;
15 import android.net.NetworkInfo;
16 import android.content.BroadcastReceiver;
17 import android.content.Intent;
18 import android.content.IntentFilter;
19 import android.content.Context;
20 import android.content.res.Resources;
21 import android.content.SharedPreferences;
22 import android.preference.PreferenceManager;
23 import android.text.format.Time;
24 import android.util.Log;
25 import android.view.View;
26 import android.view.Menu;
27 import android.view.MenuInflater;
28 import android.view.MenuItem;
29 import android.view.Window;
30 import android.view.WindowManager;
31 import android.widget.TextView;
32
33 public class WhereAmI extends Activity
34 {
35     final String TAG = getClass().getName();
36
37     private WifiManager wifiman;
38     private Boolean managewifi = false;
39     private Long updatedelay = 60000L;
40     private Integer runningtasks = 0;
41     private SharedPreferences prefs;
42     private PersistentStore store;
43
44     private class UpdateTarget {
45         private TextView tv;
46         private Oracle updater;
47         private BgUpdate task;
48
49         private class BgUpdate extends AsyncTask<Void, Void, String> {
50             @Override
51             protected String doInBackground(Void... params) {
52                 Log.v(TAG, "BgUpdate " + updater + " starting");
53                 return updater.getResult();
54             }
55         
56             @Override
57             protected void onPostExecute(String str) {
58                 Log.v(TAG, "BgUpdate callback executing");
59                 tv.setText(str);
60                 runningtasks--;
61                 if (runningtasks <= 0) {
62                     if (managewifi) {
63                         boolean wifion = wifiman.setWifiEnabled(false);
64                         Log.v(TAG, "disabling wifi result " + wifion);
65                     }
66                     Time tm = new Time();
67                     tm.setToNow();
68                     tvs.setText(R.string.lasttry);
69                     tvs.append(tm.format(" %d/%m/%Y %H:%M"));
70                 }
71             }
72
73             @Override
74             protected void onCancelled() {
75                 Log.v(TAG, "BgUpdate callback cancelled");
76                 runningtasks--;
77             }
78         }
79
80         public UpdateTarget(TextView tv, Oracle updater) {
81             this.tv = tv;
82             this.updater = updater;
83         }
84
85         public void launch() {
86             tv.setText(R.string.updating);
87             task = new BgUpdate();
88             task.execute();
89         }
90
91         public void cancel() {
92             task.cancel(true);
93         }
94     }
95     private UpdateTarget[] ut;
96
97     private TextView tvt, tvd, tvs;
98     private Resources res;
99     private String[] month;
100     private String[] wday;
101
102     private Handler mHandler = new Handler();
103
104     private Runnable updateClock = new Runnable () {
105         public void run() {
106             long now = System.currentTimeMillis();
107             Time tm = new Time();
108             tm.set(now);
109             tvt.setText(tm.format("%H:%M"));
110             tm.set(now + 60000);
111             tm.second=0;
112             long next = tm.toMillis(false);
113             mHandler.postDelayed(this, next-now+1);
114         }
115     };
116
117     private Runnable updateCal = new Runnable () {
118         public void run() {
119             long now = System.currentTimeMillis();
120             Time tm = new Time();
121             tm.set(now);
122             tvd.setText(
123                        wday[tm.weekDay] +
124                        tm.format("\n%d ") +
125                        month[tm.month] +
126                        tm.format(" %Y"));
127             tm.set(now + 86400000);
128             tm.hour=0;
129             tm.minute=0;
130             tm.second=0;
131             long next = tm.toMillis(false);
132             mHandler.postDelayed(this, next-now+1);
133         }
134     };
135
136     private Runnable updateInfo = new Runnable () {
137         public void run() {
138             Log.v(TAG, "updateInfo starting");
139             if (managewifi) {
140                 IntentFilter intentFilter =
141                     new IntentFilter("android.net.conn.CONNECTIVITY_CHANGE");
142                 registerReceiver(connChanged,intentFilter);
143                 connChangedRegistered = true;
144                 boolean wifion = wifiman.setWifiEnabled(true);
145                 Log.v(TAG, "enabling wifi result " + wifion);
146             } else {
147                 for (int i = 0; i < ut.length; i++) {
148                     runningtasks++;
149                     ut[i].launch();
150                 }
151             }
152             mHandler.postDelayed(resetInfo, 50000);
153             mHandler.postDelayed(this, updatedelay);
154         }
155     };
156
157     private Runnable resetInfo = new Runnable () {
158         public void run() {
159             Log.v(TAG, "resetInfo starting");
160             if (connChangedRegistered) {
161                 unregisterReceiver(connChanged);
162                 connChangedRegistered = false;
163             }
164             if (runningtasks > 0) {
165                 for (int i = 0; i < ut.length; i++) {
166                     ut[i].cancel();
167                 }
168                 Time tm = new Time();
169                 tm.setToNow();
170                 tvs.setText(R.string.failtry);
171                 tvs.append(tm.format(" %d/%m/%Y %H:%M:%S"));
172             }
173             if (managewifi) {
174                 boolean wifion = wifiman.setWifiEnabled(false);
175                 Log.v(TAG, "disabling wifi result " + wifion);
176             }
177         }
178     };
179
180     private boolean connChangedRegistered = false;
181     private final BroadcastReceiver connChanged = new BroadcastReceiver() {
182         @Override
183         public void onReceive(Context context, Intent intent) {
184             ConnectivityManager cm = (ConnectivityManager)context.
185                            getSystemService(Context.CONNECTIVITY_SERVICE);
186             NetworkInfo activeNetwork = cm.getActiveNetworkInfo();
187             boolean isConnected = activeNetwork != null &&
188                                   activeNetwork.isConnectedOrConnecting();
189             Log.v(TAG, "Connectivity changed to " + isConnected);
190             if (isConnected) {
191                 for (int i = 0; i < ut.length; i++) {
192                     runningtasks++;
193                     ut[i].launch();
194                 }
195             }
196         }
197     };
198
199     /** Called when the activity is first created. */
200     @Override
201     public void onCreate(Bundle savedInstanceState) {
202         super.onCreate(savedInstanceState);
203         if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.FROYO) {
204             Log.v(TAG, "Disabling keepalive for build version " +
205                        Build.VERSION.SDK_INT);
206             System.setProperty("http.keepAlive", "false");
207         } else {
208             Log.v(TAG, "Post-Froyo version " +
209                         Build.VERSION.SDK_INT);
210         }
211         prefs = PreferenceManager.getDefaultSharedPreferences(this);
212         store = new PersistentStore(prefs);
213         wifiman = (WifiManager)getSystemService(Context.WIFI_SERVICE);
214         requestWindowFeature(Window.FEATURE_NO_TITLE);
215         getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
216         setContentView(R.layout.main);
217         res = getResources();
218         month = res.getStringArray(R.array.month);
219         wday = res.getStringArray(R.array.wday);
220         tvt = (TextView)findViewById(R.id.time);
221         tvd = (TextView)findViewById(R.id.date);
222         tvs = (TextView)findViewById(R.id.timestamp);
223         ut = new UpdateTarget[] {
224             new UpdateTarget((TextView)findViewById(R.id.location),
225                              new PhoneLog(res, store)),
226             new UpdateTarget((TextView)findViewById(R.id.phonecall),
227                              new LastLocation(res, store))
228         };
229         Log.v(TAG, "created UI, about to start update task");
230         mHandler.post(updateClock);
231         mHandler.post(updateCal);
232         mHandler.post(updateInfo);
233         Log.v(TAG, "created UI, update task created");
234     }
235
236     /** Called when reactivated */
237     @Override
238     public void onResume() {
239         super.onResume();
240         boolean fullscreen = prefs.getBoolean("fullscreen", false);
241         managewifi = prefs.getBoolean("managewifi", false);
242         updatedelay = Long.parseLong(prefs.getString("updateperiod", "1200000"));
243         Log.v("WhereAmI", "fullscreen: " + fullscreen +
244                           ", managewifi: " + managewifi +
245                           ", updatedelay: " + updatedelay);
246         if (fullscreen) {
247             getWindow().addFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN);
248             getWindow().clearFlags(WindowManager.LayoutParams.
249                                                   FLAG_FORCE_NOT_FULLSCREEN);
250         } else {
251             getWindow().clearFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN);
252         }
253     }
254
255     /** Called when put to background */
256     @Override
257     public void onPause() {
258         super.onPause();
259         Log.v(TAG, "going background");
260     }
261
262     /** Called when the activity is destroyed. */
263     @Override
264     public void onDestroy() {
265         super.onDestroy();
266         Log.v(TAG, "going down");
267         mHandler.removeCallbacks(updateClock);
268         mHandler.removeCallbacks(updateCal);
269         mHandler.removeCallbacks(updateInfo);
270         if (connChangedRegistered) {
271             unregisterReceiver(connChanged);
272             connChangedRegistered = false;
273         }
274         if (managewifi) {
275             boolean wifion = wifiman.setWifiEnabled(false);
276             Log.v(TAG, "disabling wifi result " + wifion);
277         }
278     }
279
280     /** Called when the menu is activated. */
281     @Override
282     public boolean onCreateOptionsMenu(Menu menu) {
283         MenuInflater inflater = getMenuInflater();
284         inflater.inflate(R.menu.main_menu, menu);
285         return true;
286     }
287
288     /** Called when the menu item is selected */
289     @Override
290     public boolean onOptionsItemSelected(MenuItem item) {
291         switch (item.getItemId()) {
292         case R.id.quit:
293             finish();
294             return true;
295         case R.id.authorize:
296             Log.v(TAG, "authorize requested");
297             startActivity(new Intent(this, Authorize.class));
298             return true;
299         case R.id.settings:
300             Log.v(TAG, "settings requested");
301             startActivity(new Intent(this, WhereAmIprefs.class));
302             return true;
303         default:
304             return super.onOptionsItemSelected(item);
305         }
306     }
307 }