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