package org.average.whereami;
import org.average.whereami.WhereAmIprefs;
+import org.average.whereami.APIBase;
+import org.average.whereami.Oracle;
+import org.average.whereami.PhoneLog;
+import org.average.whereami.LastLocation;
+
+import java.util.Random;
import android.app.Activity;
import android.net.wifi.WifiManager;
+import android.os.Build;
import android.os.Bundle;
import android.os.AsyncTask;
import android.os.Handler;
import android.text.format.Time;
import android.util.Log;
import android.view.View;
+import android.view.KeyEvent;
import android.view.Menu;
import android.view.MenuInflater;
import android.view.MenuItem;
public class WhereAmI extends Activity
{
+ final String TAG = getClass().getName();
+
private WifiManager wifiman;
+ private Boolean managewifi = false;
private Long updatedelay = 60000L;
private Integer runningtasks = 0;
private SharedPreferences prefs;
+ private PersistentStore store;
+ private Random random = new Random();
+ private Boolean revive = false;
+ private Context context;
private class UpdateTarget {
private TextView tv;
- private Integer updater; // will be the function/object
+ private Oracle updater;
private BgUpdate task;
private class BgUpdate extends AsyncTask<Void, Void, String> {
@Override
protected String doInBackground(Void... params) {
- Log.w("WhereAmI", "BgUpdate " + updater + " starting");
- SystemClock.sleep(5000); // real job do be done here
- Log.w("WhereAmI", "BgUpdate about to return");
- return "5 seconds passed in " + updater;
+ Log.v(TAG, "BgUpdate " + updater + " starting");
+ Utterance result = updater.getResult();
+ for (int i = 2; !result.success && i <= 3; i++) {
+ SystemClock.sleep(1000 + random.nextInt(1000));
+ result = updater.getResult();
+ }
+ if (!result.success) {
+ Log.e(TAG, "After third attempt still " +
+ result.message);
+ }
+ return result.message;
}
@Override
protected void onPostExecute(String str) {
- Log.w("WhereAmI", "BgUpdate callback executing");
+ Log.v(TAG, "BgUpdate callback executing");
tv.setText(str);
runningtasks--;
if (runningtasks <= 0) {
- boolean wifion = wifiman.setWifiEnabled(false);
- Log.w("WhereAmI", "disabling wifi result " + wifion);
+ if (managewifi) {
+ boolean wifion = wifiman.setWifiEnabled(false);
+ Log.v(TAG, "disabling wifi result " + wifion);
+ }
Time tm = new Time();
tm.setToNow();
tvs.setText(R.string.lasttry);
- tvs.append(tm.format(" %d/%m/%Y %H:%M:%S"));
+ tvs.append(tm.format(" %d/%m/%Y %H:%M"));
}
}
@Override
protected void onCancelled() {
- Log.w("WhereAmI", "BgUpdate callback cancelled");
+ Log.v(TAG, "BgUpdate callback cancelled");
runningtasks--;
}
}
- public UpdateTarget(TextView tv, Integer updater) {
+ public UpdateTarget(TextView tv, Oracle updater) {
this.tv = tv;
this.updater = updater;
}
private Handler mHandler = new Handler();
+ private Runnable reviveSelf = new Runnable() {
+ public void run() {
+ Log.v(TAG, "trying to revive self");
+ Intent intent = new Intent(Intent.ACTION_MAIN);
+ intent.addCategory(Intent.CATEGORY_LAUNCHER );
+ intent.setClass(context, WhereAmI.class);
+ intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+ intent.addFlags(Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED);
+ intent.addFlags(Intent.FLAG_FROM_BACKGROUND);
+ intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
+ startActivity(intent);
+ }
+ };
+
private Runnable updateClock = new Runnable () {
public void run() {
long now = System.currentTimeMillis();
private Runnable updateInfo = new Runnable () {
public void run() {
- Log.w("WhereAmI", "updateInfo starting");
- IntentFilter intentFilter =
- new IntentFilter("android.net.conn.CONNECTIVITY_CHANGE");
- registerReceiver(connChanged,intentFilter);
- connChangedRegistered = true;
- boolean wifion = wifiman.setWifiEnabled(true);
- Log.w("WhereAmI", "enabling wifi result " + wifion);
- mHandler.postDelayed(resetInfo, updatedelay);
- mHandler.postDelayed(this, 60000);
+ Log.v(TAG, "updateInfo starting");
+ if (managewifi) {
+ IntentFilter intentFilter =
+ new IntentFilter("android.net.conn.CONNECTIVITY_CHANGE");
+ registerReceiver(connChanged,intentFilter);
+ connChangedRegistered = true;
+ boolean wifion = wifiman.setWifiEnabled(true);
+ Log.v(TAG, "enabling wifi result " + wifion);
+ } else {
+ for (int i = 0; i < ut.length; i++) {
+ runningtasks++;
+ ut[i].launch();
+ }
+ }
+ mHandler.postDelayed(resetInfo, 50000);
+ mHandler.postDelayed(this, updatedelay);
}
};
private Runnable resetInfo = new Runnable () {
public void run() {
- Log.w("WhereAmI", "resetInfo starting");
+ Log.v(TAG, "resetInfo starting");
if (connChangedRegistered) {
unregisterReceiver(connChanged);
connChangedRegistered = false;
for (int i = 0; i < ut.length; i++) {
ut[i].cancel();
}
+ runningtasks = 0;
Time tm = new Time();
tm.setToNow();
tvs.setText(R.string.failtry);
- tvs.append(tm.format(" %d/%m/%Y %H:%M:%S"));
+ tvs.append(tm.format(" %d/%m/%Y %H:%M"));
+ }
+ if (managewifi) {
+ boolean wifion = wifiman.setWifiEnabled(false);
+ Log.v(TAG, "disabling wifi result " + wifion);
}
- boolean wifion = wifiman.setWifiEnabled(false);
- Log.w("WhereAmI", "disabling wifi result " + wifion);
}
};
NetworkInfo activeNetwork = cm.getActiveNetworkInfo();
boolean isConnected = activeNetwork != null &&
activeNetwork.isConnectedOrConnecting();
- Log.w("WhereAmI", "Connectivity changed to " + isConnected);
+ Log.v(TAG, "Connectivity changed to " + isConnected);
if (isConnected) {
for (int i = 0; i < ut.length; i++) {
runningtasks++;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
+ context = this;
+ if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.FROYO) {
+ Log.v(TAG, "Disabling keepalive for build version " +
+ Build.VERSION.SDK_INT);
+ System.setProperty("http.keepAlive", "false");
+ } else {
+ Log.v(TAG, "Post-Froyo version " +
+ Build.VERSION.SDK_INT);
+ }
+ prefs = PreferenceManager.getDefaultSharedPreferences(this);
+ store = new PersistentStore(prefs);
wifiman = (WifiManager)getSystemService(Context.WIFI_SERVICE);
requestWindowFeature(Window.FEATURE_NO_TITLE);
getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
tvt = (TextView)findViewById(R.id.time);
tvd = (TextView)findViewById(R.id.date);
tvs = (TextView)findViewById(R.id.timestamp);
+ APIBase base = new APIBase(res, store);
ut = new UpdateTarget[] {
- new UpdateTarget((TextView)findViewById(R.id.location), 1),
- new UpdateTarget((TextView)findViewById(R.id.phonecall), 2)
+ new UpdateTarget((TextView)findViewById(R.id.phonecall),
+ new PhoneLog(base)),
+ new UpdateTarget((TextView)findViewById(R.id.location),
+ new LastLocation(base))
};
- Log.w("WhereAmI", "created UI, about to start update task");
- mHandler.post(updateClock);
- mHandler.post(updateCal);
- mHandler.post(updateInfo);
- Log.w("WhereAmI", "created UI, update task created");
}
/** Called when reactivated */
@Override
public void onResume() {
super.onResume();
- prefs = PreferenceManager.getDefaultSharedPreferences(this);
boolean fullscreen = prefs.getBoolean("fullscreen", false);
+ managewifi = prefs.getBoolean("managewifi", false);
updatedelay = Long.parseLong(prefs.getString("updateperiod", "1200000"));
+ Log.v("WhereAmI", "fullscreen: " + fullscreen +
+ ", managewifi: " + managewifi +
+ ", updatedelay: " + updatedelay);
if (fullscreen) {
getWindow().addFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN);
getWindow().clearFlags(WindowManager.LayoutParams.
} else {
getWindow().clearFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN);
}
+ revive = true;
+ mHandler.post(updateClock);
+ mHandler.post(updateCal);
+ mHandler.post(updateInfo);
+ Log.v(TAG, "update tasks scheduled");
}
/** Called when put to background */
@Override
public void onPause() {
super.onPause();
- Log.w("WhereAmI", "going background");
+ Log.v(TAG, "going background");
+ resetInfo.run();
+ mHandler.removeCallbacks(updateClock);
+ mHandler.removeCallbacks(updateCal);
+ mHandler.removeCallbacks(updateInfo);
+ if (revive) {
+ Log.v(TAG, "scheduling revival");
+ mHandler.postDelayed(reviveSelf, 6000); // 6 second delay
+ }
}
/** Called when the activity is destroyed. */
@Override
public void onDestroy() {
super.onDestroy();
- Log.w("WhereAmI", "going down");
- mHandler.removeCallbacks(updateClock);
- mHandler.removeCallbacks(updateCal);
- mHandler.removeCallbacks(updateInfo);
- if (connChangedRegistered) {
- unregisterReceiver(connChanged);
- connChangedRegistered = false;
- }
- boolean wifion = wifiman.setWifiEnabled(false);
- Log.w("WhereAmI", "disabling wifi result " + wifion);
+ Log.v(TAG, "going down");
}
/** Called when the menu is activated. */
public boolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()) {
case R.id.quit:
+ revive = false;
finish();
return true;
+ case R.id.authorize:
+ Log.v(TAG, "authorize requested");
+ startActivity(new Intent(this, Authorize.class));
+ return true;
case R.id.settings:
- Log.w("WhereAmI", "settings requested");
+ Log.v(TAG, "settings requested");
startActivity(new Intent(this, WhereAmIprefs.class));
return true;
default:
return super.onOptionsItemSelected(item);
}
}
+
+ /** Override "back" button. Can still quit via menu. */
+ @Override
+ public boolean onKeyDown(int keyCode, KeyEvent event) {
+ if (keyCode == KeyEvent.KEYCODE_BACK) {
+ return true;
+ }
+ return super.onKeyDown(keyCode, event);
+ }
}
projects / WhereAmI.git / blobdiff