Changeset defcd5c in orbit


Ignore:
Timestamp:
12/16/13 15:57:05 (7 years ago)
Author:
Steve Castellotti <sc@…>
Branches:
master, Servo
Children:
cf3a627
Parents:
892074d
Message:
  • handlerThinkGear moved to Flight fragment
Location:
android/src/info/puzzlebox/orbit
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • android/src/info/puzzlebox/orbit/FragmentTabFlight.java

    r892074d rdefcd5c  
    88import java.util.Arrays; 
    99 
     10import android.bluetooth.BluetoothAdapter; 
    1011import android.content.res.Configuration; 
    1112import android.graphics.Color; 
     
    1415import android.graphics.drawable.shapes.RoundRectShape; 
    1516import android.os.Bundle; 
     17import android.os.Handler; 
    1618import android.os.Message; 
    1719import android.util.Log; 
     
    2628import android.widget.ProgressBar; 
    2729import android.widget.SeekBar; 
     30import android.widget.Toast; 
    2831 
    2932//import android.app.Fragment; 
     
    3437import com.androidplot.xy.SimpleXYSeries; 
    3538import com.androidplot.xy.XYPlot; 
     39 
    3640import com.neurosky.thinkgear.TGDevice; 
    3741 
    3842 
     43//public class FragmentTabFlight extends Fragment implements OnClickListener, SeekBar.OnSeekBarChangeListener { 
    3944public class FragmentTabFlight extends Fragment implements OnClickListener, SeekBar.OnSeekBarChangeListener { 
    4045 
     
    119124        String TAG = "FragmentFlight"; 
    120125 
     126         
     127        /** 
     128         * Bluetooth 
     129         */ 
     130        BluetoothAdapter bluetoothAdapter; 
     131        //      ArrayList<String> pairedBluetoothDevices; 
     132 
     133 
     134        /** 
     135         * NeuroSky ThinkGear Device 
     136         */ 
     137        TGDevice tgDevice; 
     138        int tgSignal = 0; 
     139//      int[] thresholdValuesAttention = new int[101]; 
     140//      int[] thresholdValuesMeditation = new int[101]; 
     141//      int minimumPower = 0; // minimum power for the helicopter throttle 
     142//      int maximumPower = 100; // maximum power for the helicopter throttle 
     143        String currentCommand = "neutral"; 
     144        //      final boolean rawEnabled = false; 
     145        final boolean rawEnabled = true; 
     146         
    121147 
    122148        //      OnClickListener Flight_enterOnClickListener 
     
    258284                connectButton.setOnClickListener(this); 
    259285 
    260  
    261                 //                      layoutControl = (LinearLayout) v.findViewById(R.id.layoutControl); 
    262                 //                      layoutAudioService = (LinearLayout) v.findViewById(R.id.layoutAudioService); 
    263                 //                      layoutAdvancedOptions = (LinearLayout) v.findViewById(R.id.layoutAdvancedOptions); 
    264                 //                      layoutInvertControlSignal = (LinearLayout) v.findViewById(R.id.layoutInvertControlSignal); 
     286                 
     287                /** 
     288                 * Prepare Bluetooth and NeuroSky ThinkGear EEG interface 
     289                 */ 
     290 
     291                bluetoothAdapter = BluetoothAdapter.getDefaultAdapter(); 
     292 
     293                if(bluetoothAdapter == null) { 
     294                        // Alert user that Bluetooth is not available 
     295                        //                      Toast.makeText(this, "Bluetooth not available", Toast.LENGTH_LONG).show(); 
     296                        Toast.makeText(((OrbitTabActivity)getActivity()), "Bluetooth not available", Toast.LENGTH_LONG).show(); 
     297 
     298                } else { 
     299                        /** create the TGDevice */ 
     300                        tgDevice = new TGDevice(bluetoothAdapter, handlerThinkGear); 
     301 
     302                        /** Retrieve a list of paired Bluetooth adapters */ 
     303                        //                      Set<BluetoothDevice> pairedDevices = bluetoothAdapter.getBondedDevices(); 
     304                        //                      pairedBluetoothDevices = new ArrayList<String>(Arrays.asList(pairedDevices.toString())); 
     305                        /**  
     306                         * NOTE: To get device names iterate through pairedBluetoothDevices  
     307                         * and call the getName() method on each BluetoothDevice object.  
     308                         */ 
     309                } 
    265310 
    266311 
     
    432477        } // updateStatusImage 
    433478 
    434          
     479 
    435480        // ################################################################ 
    436481 
    437482        public void onClick(View v) { 
    438                  
     483 
    439484                switch (v.getId()) { 
    440                  
     485 
    441486                case R.id.buttonConnect: 
    442                          
    443 //                      connectHeadset(v); 
    444                         ((OrbitTabActivity)getActivity()).connectHeadset(v); 
    445                          
    446                  
    447                 } 
    448                  
     487 
     488                                                connectHeadset(v); 
     489//                      ((OrbitTabActivity)getActivity()).connectHeadset(v); 
     490 
     491 
     492                } 
     493 
    449494        } // onClick 
    450495 
    451          
     496 
    452497        // ################################################################ 
    453498 
     
    481526        } // onStopTrackingTouch 
    482527 
     528         
     529        // ################################################################ 
     530 
     531        private final Handler handlerThinkGear = new Handler() { 
     532 
     533                /** 
     534                 * Handles data packets from NeuroSky ThinkGear device 
     535                 */ 
     536 
     537//              @SuppressLint("HandlerLeak") 
     538//              @Override 
     539                public void handleMessage(Message msg) { 
     540 
     541                        parseEEG(msg); 
     542 
     543                } 
     544                 
     545        }; // handlerThinkGear 
     546         
    483547 
    484548        // ################################################################ 
     
    494558                                break; 
    495559                        case TGDevice.STATE_CONNECTING: 
     560                                if (DEBUG) 
     561                                        Log.v(TAG, "Connecting to EEG"); 
     562                                appendDebugConsole("Connecting to EEG\n"); 
    496563                                eegConnecting = true; 
    497564                                eegConnected = false; 
     
    499566                                break; 
    500567                        case TGDevice.STATE_CONNECTED: 
     568                                if (DEBUG) 
     569                                        Log.v(TAG, "EEG Connected"); 
     570                                appendDebugConsole("Bluetooth Connected\n"); 
    501571                                setButtonText(R.id.buttonConnect, "Disconnect"); 
    502572                                eegConnecting = false; 
    503573                                eegConnected = true; 
    504574                                updateStatusImage(); 
     575                                tgDevice.start(); 
    505576                                break; 
    506577                        case TGDevice.STATE_NOT_FOUND: 
     578                                if (DEBUG) 
     579                                        Log.v(TAG, "EEG headset not found"); 
     580                                appendDebugConsole("EEG headset not found\n"); 
    507581                                eegConnecting = false; 
    508582                                eegConnected = false; 
     
    510584                                break; 
    511585                        case TGDevice.STATE_NOT_PAIRED: 
     586                                if (DEBUG) 
     587                                        Log.v(TAG, "EEG headset not paired"); 
     588                                appendDebugConsole("EEG headset not paired\n"); 
    512589                                eegConnecting = false; 
    513590                                eegConnected = false; 
     
    515592                                break; 
    516593                        case TGDevice.STATE_DISCONNECTED: 
     594                                if (DEBUG) 
     595                                        Log.v(TAG, "EEG Disconnected"); 
     596                                appendDebugConsole("EEG Disconnected\n"); 
    517597                                eegConnecting = false; 
    518598                                eegConnected = false; 
    519599                                updateStatusImage(); 
     600                                disconnectHeadset(); 
    520601                                break; 
    521602                        } 
     
    528609                        progressBarSignal.setProgress(eegSignal); 
    529610                        updateStatusImage(); 
    530                         break; 
    531                 case TGDevice.MSG_RAW_DATA: 
    532  
    533                         //                      rawEEG[arrayIndex] = msg.arg1; 
    534                         //                      arrayIndex = arrayIndex + 1; 
    535  
    536                         //                      if (arrayIndex == EEG_RAW_HISTORY_SIZE - 1) 
    537                         //                              updateEEGRawHistory(); 
    538  
    539                         break; 
    540                 case TGDevice.MSG_HEART_RATE: 
    541                         //                              appendDebugConsole("Heart rate: " + msg.arg1 + "\n"); 
    542611                        break; 
    543612                case TGDevice.MSG_ATTENTION: 
     
    560629                        //tv.append("Blink: " + msg.arg1 + "\n"); 
    561630                        break; 
     631                case TGDevice.MSG_RAW_DATA: 
     632 
     633                        rawEEG[arrayIndex] = msg.arg1; 
     634                        arrayIndex = arrayIndex + 1; 
     635 
     636                        if (arrayIndex == EEG_RAW_HISTORY_SIZE - 1) 
     637                                updateEEGRawHistory(rawEEG); 
     638 
     639                        break; 
    562640                case TGDevice.MSG_RAW_COUNT: 
    563641                        //tv.append("Raw Count: " + msg.arg1 + "\n"); 
    564                         break; 
    565                 case TGDevice.MSG_LOW_BATTERY: 
    566                         //                              Toast.makeText(getApplicationContext(), "Low battery!", Toast.LENGTH_SHORT).show(); 
    567642                        break; 
    568643                case TGDevice.MSG_RAW_MULTI: 
    569644                        //TGRawMulti rawM = (TGRawMulti)msg.obj; 
    570645                        //tv.append("Raw1: " + rawM.ch1 + "\nRaw2: " + rawM.ch2); 
     646                case TGDevice.MSG_HEART_RATE: 
     647                        //                              appendDebugConsole("Heart rate: " + msg.arg1 + "\n"); 
     648                        break; 
     649                case TGDevice.MSG_LOW_BATTERY: 
     650                        //                      Toast.makeText(getApplicationContext(), "Low battery!", Toast.LENGTH_SHORT).show(); 
     651                        Toast.makeText(((OrbitTabActivity)getActivity()), "EEG battery low!", Toast.LENGTH_SHORT).show(); 
     652                        break; 
    571653                default: 
    572654                        break; 
     
    575657        } // handleMessage 
    576658 
     659         
     660        // ################################################################ 
     661 
     662        public void connectHeadset(View view) { 
     663 
     664                /** 
     665                 * Called when the "Connect" button is pressed 
     666                 */ 
     667 
     668                Log.v(TAG, "connectHeadset()"); 
     669                 
     670//              ((OrbitTabActivity)getActivity()).connectHeadset(v); 
     671 
     672 
     673                /** Stop audio stream */ 
     674                ((OrbitTabActivity)getActivity()).stopControl(); 
     675 
     676                if(bluetoothAdapter == null) { 
     677 
     678                        // Alert user that Bluetooth is not available 
     679                        Toast.makeText(((OrbitTabActivity)getActivity()), "Bluetooth not available", Toast.LENGTH_LONG).show(); 
     680 
     681                } else { 
     682 
     683                        if (tgDevice.getState() != TGDevice.STATE_CONNECTING && tgDevice.getState() != TGDevice.STATE_CONNECTED) { 
     684                                tgDevice.connect(rawEnabled); 
     685                                ((OrbitTabActivity)getActivity()).maximizeAudioVolume(); // Automatically set media volume to maximum 
     686                        } 
     687 
     688 
     689                        else if (tgDevice.getState() == TGDevice.STATE_CONNECTED) 
     690                                /** "Disconnect" button was pressed */ 
     691                                disconnectHeadset(); 
     692 
     693                } 
     694 
     695        } // connectHeadset 
     696 
     697         
    577698 
    578699        // ################################################################ 
     
    600721                setButtonText(R.id.buttonConnect, "Connect"); 
    601722 
     723                 
     724                if (tgDevice.getState() == TGDevice.STATE_CONNECTED) { 
     725                        tgDevice.stop(); 
     726                        tgDevice.close(); 
     727 
     728                        ((OrbitTabActivity)getActivity()).stopControl(); 
     729 
     730                        disconnectHeadset(); 
     731 
     732                } 
     733                //              else if (eegDevice == "Emotiv") { 
     734                // 
     735                //                      stopControl(); 
     736                // 
     737                //                      FragmentTabFlightEmotiv fragmentFlight =  
     738                //                                      (FragmentTabFlightEmotiv) getSupportFragmentManager().findFragmentByTag( getTabFragmentFlight() );               
     739                // 
     740                //                      if (fragmentFlight != null) 
     741                //                              fragmentFlight.disconnectHeadset(); 
     742                // 
     743                //              } 
     744 
     745                 
     746                 
    602747        } // disconnectHeadset 
    603748 
     
    814959                        eegRawHistoryPlot.redraw(); 
    815960 
    816                         //              rawEEG = new Number[512]; 
    817                         //              arrayIndex = 0; 
     961                                        rawEEG = new Number[512]; 
     962                                        arrayIndex = 0; 
    818963                } 
    819964 
  • android/src/info/puzzlebox/orbit/OrbitTabActivity.java

    r892074d rdefcd5c  
    6161 
    6262//public class OrbitTabActivity extends FragmentActivity implements SeekBar.OnSeekBarChangeListener { 
    63         public class OrbitTabActivity extends FragmentActivity { 
     63public class OrbitTabActivity extends FragmentActivity { 
    6464 
    6565 
     
    354354 
    355355        public boolean onUnbind(Intent intent) { 
    356                  
     356 
    357357                Log.d(this.getClass().getName(), "UNBIND"); 
    358358 
     
    554554                try { 
    555555 
    556 //                      disconnectHeadset(); 
     556                        //                      disconnectHeadset(); 
    557557 
    558558                        //                      if (eegDevice == "ThinkGear") { 
     
    567567                        } 
    568568 
    569                          
     569 
    570570                } catch (Exception e) { 
    571571                        // TODO Auto-generated catch block 
     
    588588                try { 
    589589 
    590                         disconnectHeadset(); 
     590                        //                      disconnectHeadset(); 
     591 
     592 
     593                        if (eegDevice == "ThinkGear") { 
     594                                FragmentTabFlight fragmentFlight =  
     595                                                (FragmentTabFlight) getSupportFragmentManager().findFragmentByTag( getTabFragmentFlight() ); 
     596                                fragmentFlight.disconnectHeadset(); 
     597                        } 
    591598 
    592599                } catch (Exception e) { 
     
    837844        // ################################################################ 
    838845 
    839 //      public void onProgressChanged(SeekBar seekBar, int progress, boolean fromTouch) { 
    840 // 
    841 //              updatePower(); 
    842 // 
    843 //      } // onProgressChanged 
    844  
    845  
    846         // ################################################################ 
    847  
    848 //      public void onStartTrackingTouch(SeekBar seekBar) { 
    849 // 
    850 //              /** 
    851 //               * Method required by SeekBar.OnSeekBarChangeListener 
    852 //               */ 
    853 // 
    854 // 
    855 //      } // onStartTrackingTouch 
    856  
    857  
    858         // ################################################################ 
    859  
    860 //      public void onStopTrackingTouch(SeekBar seekBar) { 
    861 // 
    862 //              /** 
    863 //               * Update AudioService.command after moving a seekBar. 
    864 //               */ 
    865 // 
    866 //              Log.v(TAG, "onStopTrackingTouch()"); 
    867 // 
    868 //              FragmentTabAdvanced fragmentAdvanced =  
    869 //                              (FragmentTabAdvanced) getSupportFragmentManager().findFragmentByTag( getTabFragmentAdvanced() ); 
    870 // 
    871 //              if (fragmentAdvanced != null) { 
    872 // 
    873 //                      Integer[] command =  { 
    874 //                                      fragmentAdvanced.seekBarThrottle.getProgress(), 
    875 //                                      fragmentAdvanced.seekBarYaw.getProgress(), 
    876 //                                      fragmentAdvanced.seekBarPitch.getProgress(), 
    877 //                                      1}; 
    878 // 
    879 //                      updateAudioHandlerCommand(command); 
    880 // 
    881 //              } 
    882 // 
    883 //      } // onStopTrackingTouch 
     846        //      public void onProgressChanged(SeekBar seekBar, int progress, boolean fromTouch) { 
     847        // 
     848        //              updatePower(); 
     849        // 
     850        //      } // onProgressChanged 
     851 
     852 
     853        // ################################################################ 
     854 
     855        //      public void onStartTrackingTouch(SeekBar seekBar) { 
     856        // 
     857        //              /** 
     858        //               * Method required by SeekBar.OnSeekBarChangeListener 
     859        //               */ 
     860        // 
     861        // 
     862        //      } // onStartTrackingTouch 
     863 
     864 
     865        // ################################################################ 
     866 
     867        //      public void onStopTrackingTouch(SeekBar seekBar) { 
     868        // 
     869        //              /** 
     870        //               * Update AudioService.command after moving a seekBar. 
     871        //               */ 
     872        // 
     873        //              Log.v(TAG, "onStopTrackingTouch()"); 
     874        // 
     875        //              FragmentTabAdvanced fragmentAdvanced =  
     876        //                              (FragmentTabAdvanced) getSupportFragmentManager().findFragmentByTag( getTabFragmentAdvanced() ); 
     877        // 
     878        //              if (fragmentAdvanced != null) { 
     879        // 
     880        //                      Integer[] command =  { 
     881        //                                      fragmentAdvanced.seekBarThrottle.getProgress(), 
     882        //                                      fragmentAdvanced.seekBarYaw.getProgress(), 
     883        //                                      fragmentAdvanced.seekBarPitch.getProgress(), 
     884        //                                      1}; 
     885        // 
     886        //                      updateAudioHandlerCommand(command); 
     887        // 
     888        //              } 
     889        // 
     890        //      } // onStopTrackingTouch 
    884891 
    885892 
     
    895902                @Override 
    896903                public void handleMessage(Message msg) { 
    897                          
     904 
    898905                        Log.v(TAG, "handlerThinkGear handleMessage()"); 
    899906 
     
    905912                        } 
    906913 
    907                         switch (msg.what) { 
    908                         case TGDevice.MSG_STATE_CHANGE: 
    909  
    910                                 switch (msg.arg1) { 
    911                                 case TGDevice.STATE_IDLE: 
    912                                         break; 
    913                                 case TGDevice.STATE_CONNECTING: 
    914                                         if (DEBUG) 
    915                                                 Log.v(TAG, "Connecting to EEG"); 
    916                                         appendDebugConsole("Connecting to EEG\n"); 
    917                                         break; 
    918                                 case TGDevice.STATE_CONNECTED: 
    919                                         if (DEBUG) 
    920                                                 Log.v(TAG, "EEG Connected"); 
    921                                         appendDebugConsole("Bluetooth Connected\n"); 
    922                                         tgDevice.start(); 
    923                                         break; 
    924                                 case TGDevice.STATE_NOT_FOUND: 
    925                                         if (DEBUG) 
    926                                                 Log.v(TAG, "EEG headset not found"); 
    927                                         appendDebugConsole("EEG headset not found\n"); 
    928                                         break; 
    929                                 case TGDevice.STATE_NOT_PAIRED: 
    930                                         if (DEBUG) 
    931                                                 Log.v(TAG, "EEG headset not paired"); 
    932                                         appendDebugConsole("EEG headset not paired\n"); 
    933                                         break; 
    934                                 case TGDevice.STATE_DISCONNECTED: 
    935                                         if (DEBUG) 
    936                                                 Log.v(TAG, "EEG Disconnected"); 
    937                                         appendDebugConsole("EEG Disconnected\n"); 
    938                                         disconnectHeadset(); 
    939                                         break; 
    940                                 } 
    941  
    942                                 break; 
    943  
    944                         case TGDevice.MSG_POOR_SIGNAL: 
    945                                 eegSignal = calculateSignal(msg.arg1); 
    946                                 if (DEBUG) 
    947                                         Log.v(TAG, "PoorSignal: " + msg.arg1); 
    948                                 //                              appendDebugConsole("\nPoorSignal: " + msg.arg1 + "\n"); 
    949                                 updatePower(); 
    950  
    951                                 break; 
    952                         case TGDevice.MSG_RAW_DATA: 
    953  
    954                                 rawEEG[arrayIndex] = msg.arg1; 
    955                                 arrayIndex = arrayIndex + 1; 
    956  
    957                                 if (arrayIndex == EEG_RAW_HISTORY_SIZE - 1) 
    958                                         updateEEGRawHistory(); 
    959  
    960                                 break; 
    961                         case TGDevice.MSG_HEART_RATE: 
    962                                 if (DEBUG) 
    963                                         Log.v(TAG, "Heart rate: " + msg.arg1); 
    964                                 //                              appendDebugConsole("Heart rate: " + msg.arg1 + "\n"); 
    965                                 break; 
    966                         case TGDevice.MSG_ATTENTION: 
    967                                 eegAttention = msg.arg1; 
    968                                 if (DEBUG) 
    969                                         Log.v(TAG, "Attention: " + eegAttention); 
    970                                 //                              appendDebugConsole("Attention: " + eegAttention + "\n"); 
    971  
    972                                 //                              dataEEGAttention.put(eegAttention); 
    973  
    974                                 updatePower(); 
    975  
    976                                 break; 
    977                         case TGDevice.MSG_MEDITATION: 
    978                                 eegMeditation = msg.arg1; 
    979                                 if (DEBUG) 
    980                                         Log.v(TAG, "Meditation: " + eegMeditation); 
    981                                 //                              appendDebugConsole("Meditation: " + eegMeditation + "\n"); 
    982  
    983                                 //                              dataEEGAttention.put(eegAttention); 
    984  
    985                                 updatePower(); 
    986  
    987                                 break; 
    988                         case TGDevice.MSG_BLINK: 
    989                                 //tv.append("Blink: " + msg.arg1 + "\n"); 
    990                                 break; 
    991                         case TGDevice.MSG_RAW_COUNT: 
    992                                 //tv.append("Raw Count: " + msg.arg1 + "\n"); 
    993                                 break; 
    994                         case TGDevice.MSG_LOW_BATTERY: 
    995                                 Toast.makeText(getApplicationContext(), "Low battery!", Toast.LENGTH_SHORT).show(); 
    996                                 break; 
    997                         case TGDevice.MSG_RAW_MULTI: 
    998                                 //TGRawMulti rawM = (TGRawMulti)msg.obj; 
    999                                 //tv.append("Raw1: " + rawM.ch1 + "\nRaw2: " + rawM.ch2); 
    1000                         default: 
    1001                                 break; 
    1002                         } 
     914                        //                      switch (msg.what) { 
     915                        //                      case TGDevice.MSG_STATE_CHANGE: 
     916                        // 
     917                        //                              switch (msg.arg1) { 
     918                        //                              case TGDevice.STATE_IDLE: 
     919                        //                                      break; 
     920                        //                              case TGDevice.STATE_CONNECTING: 
     921                        //                                      if (DEBUG) 
     922                        //                                              Log.v(TAG, "Connecting to EEG"); 
     923                        //                                      appendDebugConsole("Connecting to EEG\n"); 
     924                        //                                      break; 
     925                        //                              case TGDevice.STATE_CONNECTED: 
     926                        //                                      if (DEBUG) 
     927                        //                                              Log.v(TAG, "EEG Connected"); 
     928                        //                                      appendDebugConsole("Bluetooth Connected\n"); 
     929                        //                                      tgDevice.start(); 
     930                        //                                      break; 
     931                        //                              case TGDevice.STATE_NOT_FOUND: 
     932                        //                                      if (DEBUG) 
     933                        //                                              Log.v(TAG, "EEG headset not found"); 
     934                        //                                      appendDebugConsole("EEG headset not found\n"); 
     935                        //                                      break; 
     936                        //                              case TGDevice.STATE_NOT_PAIRED: 
     937                        //                                      if (DEBUG) 
     938                        //                                              Log.v(TAG, "EEG headset not paired"); 
     939                        //                                      appendDebugConsole("EEG headset not paired\n"); 
     940                        //                                      break; 
     941                        //                              case TGDevice.STATE_DISCONNECTED: 
     942                        //                                      if (DEBUG) 
     943                        //                                              Log.v(TAG, "EEG Disconnected"); 
     944                        //                                      appendDebugConsole("EEG Disconnected\n"); 
     945                        //                                      disconnectHeadset(); 
     946                        //                                      break; 
     947                        //                              } 
     948                        // 
     949                        //                              break; 
     950                        // 
     951                        //                      case TGDevice.MSG_POOR_SIGNAL: 
     952                        //                              eegSignal = calculateSignal(msg.arg1); 
     953                        //                              if (DEBUG) 
     954                        //                                      Log.v(TAG, "PoorSignal: " + msg.arg1); 
     955                        //                              //                              appendDebugConsole("\nPoorSignal: " + msg.arg1 + "\n"); 
     956                        //                              updatePower(); 
     957                        // 
     958                        //                              break; 
     959                        //                      case TGDevice.MSG_RAW_DATA: 
     960                        // 
     961                        //                              rawEEG[arrayIndex] = msg.arg1; 
     962                        //                              arrayIndex = arrayIndex + 1; 
     963                        // 
     964                        //                              if (arrayIndex == EEG_RAW_HISTORY_SIZE - 1) 
     965                        //                                      updateEEGRawHistory(); 
     966                        // 
     967                        //                              break; 
     968                        //                      case TGDevice.MSG_HEART_RATE: 
     969                        //                              if (DEBUG) 
     970                        //                                      Log.v(TAG, "Heart rate: " + msg.arg1); 
     971                        //                              //                              appendDebugConsole("Heart rate: " + msg.arg1 + "\n"); 
     972                        //                              break; 
     973                        //                      case TGDevice.MSG_ATTENTION: 
     974                        //                              eegAttention = msg.arg1; 
     975                        //                              if (DEBUG) 
     976                        //                                      Log.v(TAG, "Attention: " + eegAttention); 
     977                        //                              //                              appendDebugConsole("Attention: " + eegAttention + "\n"); 
     978                        // 
     979                        //                              //                              dataEEGAttention.put(eegAttention); 
     980                        // 
     981                        //                              updatePower(); 
     982                        // 
     983                        //                              break; 
     984                        //                      case TGDevice.MSG_MEDITATION: 
     985                        //                              eegMeditation = msg.arg1; 
     986                        //                              if (DEBUG) 
     987                        //                                      Log.v(TAG, "Meditation: " + eegMeditation); 
     988                        //                              //                              appendDebugConsole("Meditation: " + eegMeditation + "\n"); 
     989                        // 
     990                        //                              //                              dataEEGAttention.put(eegAttention); 
     991                        // 
     992                        //                              updatePower(); 
     993                        // 
     994                        //                              break; 
     995                        //                      case TGDevice.MSG_BLINK: 
     996                        //                              //tv.append("Blink: " + msg.arg1 + "\n"); 
     997                        //                              break; 
     998                        //                      case TGDevice.MSG_RAW_COUNT: 
     999                        //                              //tv.append("Raw Count: " + msg.arg1 + "\n"); 
     1000                        //                              break; 
     1001                        //                      case TGDevice.MSG_LOW_BATTERY: 
     1002                        //                              Toast.makeText(getApplicationContext(), "Low battery!", Toast.LENGTH_SHORT).show(); 
     1003                        //                              break; 
     1004                        //                      case TGDevice.MSG_RAW_MULTI: 
     1005                        //                              //TGRawMulti rawM = (TGRawMulti)msg.obj; 
     1006                        //                              //tv.append("Raw1: " + rawM.ch1 + "\nRaw2: " + rawM.ch2); 
     1007                        //                      default: 
     1008                        //                              break; 
     1009                        //                      } 
    10031010                } 
    10041011        }; 
     
    10071014        // ################################################################ 
    10081015 
    1009         public void connectHeadset(View view) { 
    1010  
    1011                 /** 
    1012                  * Called when the "Connect" button is pressed 
    1013                  */ 
    1014  
    1015                 Log.v(TAG, "connectHeadset()"); 
    1016  
    1017                 /** Pass message to fragmentAdvanced */ 
    1018  
    1019                 /** Stop audio stream */ 
    1020                 stopControl(); 
    1021  
    1022                 if(bluetoothAdapter == null) { 
    1023  
    1024                         // Alert user that Bluetooth is not available 
    1025                         Toast.makeText(this, "Bluetooth not available", Toast.LENGTH_LONG).show(); 
    1026  
    1027                 } else { 
    1028  
    1029                         if (tgDevice.getState() != TGDevice.STATE_CONNECTING && tgDevice.getState() != TGDevice.STATE_CONNECTED) { 
    1030                                 tgDevice.connect(rawEnabled); 
    1031                                 maximizeAudioVolume(); // Automatically set media volume to maximum 
    1032                         } 
    1033  
    1034  
    1035                         else if (tgDevice.getState() == TGDevice.STATE_CONNECTED) 
    1036                                 /** "Disconnect" button was pressed */ 
    1037                                 disconnectHeadset(); 
    1038  
    1039                 } 
    1040  
    1041         } // connectHeadset 
    1042  
    1043  
    1044         // ################################################################ 
    1045  
    1046         public void disconnectHeadset() { 
    1047  
    1048                 /** 
    1049                  * Called when "Disconnect" button is pressed 
    1050                  */ 
    1051  
    1052                 if (eegDevice == "ThinkGear") { 
    1053  
    1054                         if (tgDevice.getState() == TGDevice.STATE_CONNECTED) { 
    1055                                 tgDevice.stop(); 
    1056                                 tgDevice.close(); 
    1057                         } 
    1058  
    1059                         stopControl(); 
    1060  
    1061                         FragmentTabFlight fragmentFlight =  
    1062                                         (FragmentTabFlight) getSupportFragmentManager().findFragmentByTag( getTabFragmentFlight() );             
    1063  
    1064                         if (fragmentFlight != null) 
    1065                                 fragmentFlight.disconnectHeadset(); 
    1066  
    1067                 } 
    1068                 else if (eegDevice == "Emotiv") { 
    1069  
    1070                         stopControl(); 
    1071  
    1072                         FragmentTabFlightEmotiv fragmentFlight =  
    1073                                         (FragmentTabFlightEmotiv) getSupportFragmentManager().findFragmentByTag( getTabFragmentFlight() );               
    1074  
    1075                         if (fragmentFlight != null) 
    1076                                 fragmentFlight.disconnectHeadset(); 
    1077  
    1078                 } 
    1079  
    1080  
    1081         } // disconnectHeadset 
     1016        //      public void connectHeadset(View view) { 
     1017        // 
     1018        //              /** 
     1019        //               * Called when the "Connect" button is pressed 
     1020        //               */ 
     1021        // 
     1022        //              Log.v(TAG, "connectHeadset()"); 
     1023        // 
     1024        //              /** Pass message to fragmentAdvanced */ 
     1025        // 
     1026        //              /** Stop audio stream */ 
     1027        //              stopControl(); 
     1028        // 
     1029        //              if(bluetoothAdapter == null) { 
     1030        // 
     1031        //                      // Alert user that Bluetooth is not available 
     1032        //                      Toast.makeText(this, "Bluetooth not available", Toast.LENGTH_LONG).show(); 
     1033        // 
     1034        //              } else { 
     1035        // 
     1036        //                      if (tgDevice.getState() != TGDevice.STATE_CONNECTING && tgDevice.getState() != TGDevice.STATE_CONNECTED) { 
     1037        //                              tgDevice.connect(rawEnabled); 
     1038        //                              maximizeAudioVolume(); // Automatically set media volume to maximum 
     1039        //                      } 
     1040        // 
     1041        // 
     1042        //                      else if (tgDevice.getState() == TGDevice.STATE_CONNECTED) 
     1043        //                              /** "Disconnect" button was pressed */ 
     1044        //                              disconnectHeadset(); 
     1045        // 
     1046        //              } 
     1047        // 
     1048        //      } // connectHeadset 
     1049 
     1050 
     1051        // ################################################################ 
     1052 
     1053        //      public void disconnectHeadset() { 
     1054        // 
     1055        //              /** 
     1056        //               * Called when "Disconnect" button is pressed 
     1057        //               */ 
     1058        // 
     1059        //              if (eegDevice == "ThinkGear") { 
     1060        // 
     1061        //                      if (tgDevice.getState() == TGDevice.STATE_CONNECTED) { 
     1062        //                              tgDevice.stop(); 
     1063        //                              tgDevice.close(); 
     1064        //                      } 
     1065        // 
     1066        //                      stopControl(); 
     1067        // 
     1068        //                      FragmentTabFlight fragmentFlight =  
     1069        //                                      (FragmentTabFlight) getSupportFragmentManager().findFragmentByTag( getTabFragmentFlight() );             
     1070        // 
     1071        //                      if (fragmentFlight != null) 
     1072        //                              fragmentFlight.disconnectHeadset(); 
     1073        // 
     1074        //              } 
     1075        //              else if (eegDevice == "Emotiv") { 
     1076        // 
     1077        //                      stopControl(); 
     1078        // 
     1079        //                      FragmentTabFlightEmotiv fragmentFlight =  
     1080        //                                      (FragmentTabFlightEmotiv) getSupportFragmentManager().findFragmentByTag( getTabFragmentFlight() );               
     1081        // 
     1082        //                      if (fragmentFlight != null) 
     1083        //                              fragmentFlight.disconnectHeadset(); 
     1084        // 
     1085        //              } 
     1086        // 
     1087        // 
     1088        //      } // disconnectHeadset 
    10821089 
    10831090 
     
    11681175        // ################################################################ 
    11691176 
    1170         public void updateEEGRawHistory() { 
    1171  
    1172                 if (eegDevice == "ThinkGear") { 
    1173  
    1174                         FragmentTabFlight fragmentFlight =  
    1175                                         (FragmentTabFlight) getSupportFragmentManager().findFragmentByTag( getTabFragmentFlight() ); 
    1176  
    1177                         if (fragmentFlight != null) 
    1178                                 fragmentFlight.updateEEGRawHistory(rawEEG); 
    1179  
    1180                         rawEEG = new Number[512]; 
    1181                         arrayIndex = 0; 
    1182  
    1183                 } 
    1184  
    1185         } // updateEEGRawHistory 
     1177        //      public void updateEEGRawHistory() { 
     1178        // 
     1179        //              if (eegDevice == "ThinkGear") { 
     1180        // 
     1181        //                      FragmentTabFlight fragmentFlight =  
     1182        //                                      (FragmentTabFlight) getSupportFragmentManager().findFragmentByTag( getTabFragmentFlight() ); 
     1183        // 
     1184        //                      if (fragmentFlight != null) 
     1185        //                              fragmentFlight.updateEEGRawHistory(rawEEG); 
     1186        // 
     1187        //                      rawEEG = new Number[512]; 
     1188        //                      arrayIndex = 0; 
     1189        // 
     1190        //              } 
     1191        // 
     1192        //      } // updateEEGRawHistory 
    11861193 
    11871194 
     
    12891296 
    12901297                demoFlightMode = true; 
    1291                  
     1298 
    12921299                FragmentTabAdvanced fragmentAdvanced =  
    12931300                                (FragmentTabAdvanced) getSupportFragmentManager().findFragmentByTag( getTabFragmentAdvanced() ); 
Note: See TracChangeset for help on using the changeset viewer.