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