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.phonecall),
 225                              new PhoneLog(res, store)),
 226             new UpdateTarget((TextView)findViewById(R.id.location),
 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 }