src/org/average/whereami/WhereAmI.java

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