git.gag.com Git - fw/altos/blob - altosdroid/src/org/altusmetrum/AltosDroid/SetupActivity.java

   1 /*
   2  * Copyright © 2016 Keith Packard <keithp@keithp.com>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along
  15  * with this program; if not, write to the Free Software Foundation, Inc.,
  16  * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
  17  */
  18
  19 package org.altusmetrum.AltosDroid;
  20
  21 import java.lang.ref.WeakReference;
  22 import java.util.*;
  23 import org.altusmetrum.AltosDroid.R;
  24
  25 import android.app.Activity;
  26 import android.bluetooth.*;
  27 import android.content.*;
  28 import android.os.*;
  29 import android.view.*;
  30 import android.view.View.*;
  31 import android.widget.*;
  32 import android.widget.AdapterView.*;
  33
  34 import org.altusmetrum.altoslib_11.*;
  35
  36 public class SetupActivity extends Activity {
  37         private Spinner select_rate;
  38         private Spinner set_units;
  39         private Spinner map_type;
  40         private Spinner map_source;
  41         private Button manage_frequencies;
  42         private Button preload_maps;
  43         private Button done;
  44
  45         private boolean is_bound;
  46         private Messenger service = null;
  47
  48         public final static String EXTRA_SETUP_CHANGES = "setup_changes";
  49
  50         private ServiceConnection connection = new ServiceConnection() {
  51                 public void onServiceConnected(ComponentName className, IBinder binder) {
  52                         service = new Messenger(binder);
  53                 }
  54
  55                 public void onServiceDisconnected(ComponentName className) {
  56                         // This is called when the connection with the service has been unexpectedly disconnected - process crashed.
  57                         service = null;
  58                 }
  59         };
  60
  61         void doBindService() {
  62                 bindService(new Intent(this, TelemetryService.class), connection, Context.BIND_AUTO_CREATE);
  63                 is_bound = true;
  64         }
  65
  66         void doUnbindService() {
  67                 if (is_bound) {
  68                         // If we have received the service, and hence registered with it, then now is the time to unregister.
  69                         unbindService(connection);
  70                         is_bound = false;
  71                 }
  72         }
  73
  74         static final String[] rates = {
  75                 "38400",
  76                 "9600",
  77                 "2400",
  78         };
  79
  80         static final String[] map_types = {
  81                 "Hybrid",
  82                 "Satellite",
  83                 "Roadmap",
  84                 "Terrain"
  85         };
  86
  87         static final int[] map_type_values = {
  88                 AltosMap.maptype_hybrid,
  89                 AltosMap.maptype_satellite,
  90                 AltosMap.maptype_roadmap,
  91                 AltosMap.maptype_terrain,
  92         };
  93
  94         static final String[] map_sources = {
  95                 "Online",
  96                 "Offline"
  97         };
  98
  99         private int     set_telemetry_rate;
 100         private int     set_map_source;
 101         private int     set_map_type;
 102         private boolean set_imperial_units;
 103
 104         private int     changes = 0;
 105
 106         private void add_change(int change) {
 107                 changes |= change;
 108         }
 109
 110         private void done() {
 111                 Intent intent = new Intent();
 112                 if ((changes & AltosDroid.SETUP_BAUD) != 0)
 113                         AltosPreferences.set_telemetry_rate(1, set_telemetry_rate);
 114                 if ((changes & AltosDroid.SETUP_UNITS) != 0)
 115                         AltosPreferences.set_imperial_units(set_imperial_units);
 116                 if ((changes & AltosDroid.SETUP_MAP_SOURCE) != 0)
 117                         AltosDroidPreferences.set_map_source(set_map_source);
 118                 if ((changes & AltosDroid.SETUP_MAP_TYPE) != 0)
 119                         AltosPreferences.set_map_type(set_map_type);
 120                 intent.putExtra(EXTRA_SETUP_CHANGES, changes);
 121                 setResult(Activity.RESULT_OK, intent);
 122                 finish();
 123         }
 124
 125         private void add_strings(Spinner spinner, String[] strings, int def) {
 126                 ArrayAdapter<String> adapter = new ArrayAdapter<String>(this, android.R.layout.simple_spinner_item);
 127
 128                 for (int i = 0; i < strings.length; i++)
 129                         adapter.add(strings[i]);
 130
 131                 spinner.setAdapter(adapter);
 132                 if (def >= 0)
 133                         spinner.setSelection(def);
 134         }
 135
 136         private int default_rate_pos() {
 137                 int     default_rate = AltosPreferences.telemetry_rate(1);
 138
 139                 for (int pos = 0; pos < rates.length; pos++) {
 140                         if (string_to_rate(rates[pos]) == default_rate)
 141                                 return pos;
 142                 }
 143                 return -1;
 144         }
 145
 146         private void setBaud(int baud) {
 147                 try {
 148                         service.send(Message.obtain(null, TelemetryService.MSG_SETBAUD, baud));
 149                         set_telemetry_rate = baud;
 150                         add_change(AltosDroid.SETUP_BAUD);
 151                 } catch (RemoteException e) {
 152                 }
 153         }
 154
 155         private int string_to_rate(String baud) {
 156                 int     rate = AltosLib.ao_telemetry_rate_38400;
 157                 try {
 158                         int     value = Integer.parseInt(baud);
 159                         switch (value) {
 160                         case 2400:
 161                                 rate = AltosLib.ao_telemetry_rate_2400;
 162                                 break;
 163                         case 9600:
 164                                 rate = AltosLib.ao_telemetry_rate_9600;
 165                                 break;
 166                         case 38400:
 167                                 rate = AltosLib.ao_telemetry_rate_38400;
 168                                 break;
 169                         }
 170                 } catch (NumberFormatException e) {
 171                 }
 172                 return rate;
 173         }
 174
 175         private void setBaud(String baud) {
 176                 setBaud(string_to_rate(baud));
 177         }
 178
 179         private void select_rate(int pos) {
 180                 setBaud(rates[pos]);
 181         }
 182
 183         static final String[] units = {
 184                 "Metric",
 185                 "Imperial"
 186         };
 187
 188         private int default_units_pos() {
 189                 boolean imperial = AltosPreferences.imperial_units();
 190
 191                 if (imperial)
 192                         return 1;
 193                 return 0;
 194         }
 195
 196         private void set_units(int pos) {
 197                 switch (pos) {
 198                 default:
 199                         set_imperial_units = false;
 200                         break;
 201                 case 1:
 202                         set_imperial_units = true;
 203                         break;
 204                 }
 205                 add_change(AltosDroid.SETUP_UNITS);
 206         }
 207
 208         private int default_map_type_pos() {
 209                 int     default_map_type = AltosPreferences.map_type();
 210
 211                 for (int pos = 0; pos < map_types.length; pos++)
 212                         if (map_type_values[pos] == default_map_type)
 213                                 return pos;
 214                 return 0;
 215         }
 216
 217         private void select_map_type(int pos) {
 218                 set_map_type = map_type_values[pos];
 219                 add_change(AltosDroid.SETUP_MAP_TYPE);
 220         }
 221
 222         private int default_map_source_pos() {
 223                 int     default_source = AltosDroidPreferences.map_source();
 224
 225                 switch (default_source) {
 226                 case AltosDroidPreferences.MAP_SOURCE_OFFLINE:
 227                         return 1;
 228                 default:
 229                         return 0;
 230                 }
 231         }
 232
 233         private void select_map_source(int pos) {
 234                 switch (pos) {
 235                 default:
 236                         set_map_source = AltosDroidPreferences.MAP_SOURCE_ONLINE;
 237                         break;
 238                 case 1:
 239                         set_map_source = AltosDroidPreferences.MAP_SOURCE_OFFLINE;
 240                         break;
 241                 }
 242                 add_change(AltosDroid.SETUP_MAP_SOURCE);
 243         }
 244
 245         private void manage_frequencies(){
 246                 Intent intent = new Intent(this, ManageFrequenciesActivity.class);
 247                 startActivity(intent);
 248         }
 249
 250         private void preload_maps(){
 251                 Intent intent = new Intent(this, PreloadMapActivity.class);
 252                 startActivity(intent);
 253         }
 254
 255         @Override
 256         protected void onCreate(Bundle savedInstanceState) {
 257                 super.onCreate(savedInstanceState);
 258
 259                 // Setup the window
 260                 requestWindowFeature(Window.FEATURE_INDETERMINATE_PROGRESS);
 261                 setContentView(R.layout.setup);
 262
 263                 select_rate = (Spinner) findViewById(R.id.select_rate);
 264                 add_strings(select_rate, rates, default_rate_pos());
 265                 select_rate.setOnItemSelectedListener(new OnItemSelectedListener() {
 266                                 public void onItemSelected(AdapterView<?> parent, View view, int pos, long id) {
 267                                         select_rate(pos);
 268                                 }
 269                                 public void onNothingSelected(AdapterView<?> parent) {
 270                                 }
 271                         });
 272
 273                 set_units = (Spinner) findViewById(R.id.set_units);
 274                 add_strings(set_units, units, default_units_pos());
 275                 set_units.setOnItemSelectedListener(new OnItemSelectedListener() {
 276                                 public void onItemSelected(AdapterView<?> parent, View view, int pos, long id) {
 277                                         set_units(pos);
 278                                 }
 279                                 public void onNothingSelected(AdapterView<?> parent) {
 280                                 }
 281                         });
 282
 283                 map_type = (Spinner) findViewById(R.id.map_type);
 284                 add_strings(map_type, map_types, default_map_type_pos());
 285                 map_type.setOnItemSelectedListener(new OnItemSelectedListener() {
 286                                 public void onItemSelected(AdapterView<?> parent, View view, int pos, long id) {
 287                                         select_map_type(pos);
 288                                 }
 289                                 public void onNothingSelected(AdapterView<?> parent) {
 290                                 }
 291                         });
 292
 293                 map_source = (Spinner) findViewById(R.id.map_source);
 294                 add_strings(map_source, map_sources, default_map_source_pos());
 295                 map_source.setOnItemSelectedListener(new OnItemSelectedListener() {
 296                                 public void onItemSelected(AdapterView<?> parent, View view, int pos, long id) {
 297                                         select_map_source(pos);
 298                                 }
 299                                 public void onNothingSelected(AdapterView<?> parent) {
 300                                 }
 301                         });
 302
 303
 304                 manage_frequencies = (Button) findViewById(R.id.manage_frequencies);
 305                 manage_frequencies.setOnClickListener(new OnClickListener() {
 306                                 public void onClick(View v) {
 307                                         manage_frequencies();
 308                                 }
 309                         });
 310
 311                 preload_maps = (Button) findViewById(R.id.preload_maps);
 312                 preload_maps.setOnClickListener(new OnClickListener() {
 313                                 public void onClick(View v) {
 314                                         preload_maps();
 315                                 }
 316                         });
 317
 318                 done = (Button) findViewById(R.id.done);
 319                 done.setOnClickListener(new OnClickListener() {
 320                                 public void onClick(View v) {
 321                                         done();
 322                                 }
 323                         });
 324
 325                 // Set result for when the user backs out
 326                 setResult(Activity.RESULT_CANCELED);
 327         }
 328
 329         @Override
 330         protected void onStart() {
 331                 super.onStart();
 332                 doBindService();
 333         }
 334
 335         @Override
 336         protected void onStop() {
 337                 super.onStop();
 338                 doUnbindService();
 339         }
 340 }