source: orbit/iOS/Orbit/Orbit/controllers/FlightViewController.m @ af91708

//
//  FlightViewController.m
//  Orbit
//
//  Copyright (c) 2013 Puzzlebox Productions, LLC. All rights reserved.
//  Originally created by Jonathon Horsman.
//
//  This code is released under the GNU Public License (GPL) version 2
//  For more information please refer to http://www.gnu.org/copyleft/gpl.html
//

#import <QuartzCore/QuartzCore.h>
#import "FlightViewController.h"
#import "AppDelegate.h"
#import "SignalConverter.h"

#define STATUS_DEFAULT 0
#define STATUS_CONNECTING 1
#define STATUS_CONNECTED 2
#define STATUS_PROCESSING 3
#define STATUS_ACTIVE 4

@implementation FlightViewController {
   SignalConverter *signalConverter;
   int deviceStatus;
   BOOL warned;
}

@synthesize attention, meditation, signal, power, attentionThreshold, meditationThreshold, connectButton, testButton, statusImage, signalPercent, attentionPercent, meditationPercent, powerPercent;

- (void)viewDidLoad
{
   [super viewDidLoad];
   
   attention.progressTintColor = [UIColor redColor];
   self.attentionThreshold.minimumTrackTintColor = [UIColor grayColor];
   meditation.progressTintColor = [UIColor blueColor];
   self.meditationThreshold.minimumTrackTintColor = [UIColor grayColor];
   self.meditationThreshold.value = 0;
   
   AppDelegate *appDelegate = (AppDelegate *)[[UIApplication sharedApplication] delegate];
   signalConverter = appDelegate.signalConverter;
   
   signalConverter.delegate = self;
   [self setThresholds];
   [self.attentionThreshold addTarget:self action:@selector(setThresholds) forControlEvents:UIControlEventValueChanged];
   [self.meditationThreshold addTarget:self action:@selector(setThresholds) forControlEvents:UIControlEventValueChanged];
   
}

#pragma mark view updates

// Set all levels back to zero
- (void) resetViews
{
   signal.progress = 0;
   signalPercent.text = @"0%";
   attention.progress = 0;
   attentionPercent.text = @"0%";
   meditation.progress = 0;
   meditationPercent.text = @"0%";
   power.progress = 0;
   powerPercent.text = @"0%";
   [self updateStatusImage:STATUS_DEFAULT];
   connectButton.title = @"Connect";
}

- (void) updateStatusImage:(int) statusNo
{
   if (statusNo != deviceStatus) {
      [statusImage setImage: [UIImage imageNamed:[NSString stringWithFormat:@"status_%u", statusNo]]];
      deviceStatus = statusNo;
   }
}

- (void) setThresholds
{
   [signalConverter setValuesForAttention:attentionThreshold.value meditation:meditationThreshold.value];
}

#pragma mark - SignalConverterDelegate methods

- (void) updatedValuesForSignal: (float)signalStrength
                      attention: (float)attentionLevel
                     meditation: (float)meditationLevel
                          power: (float)powerLevel
{
   
   // Set Attention and Meditation to zero if we've lost signal
   if (signalStrength < 100.0) {
      attentionLevel = 0.000000;
      meditationLevel = 0.000000;
      powerLevel = 0.000000;
   }
   
   self.signal.progress = signalStrength / 100;
   self.signalPercent.text = [NSString stringWithFormat:@"%i%%", (int)(signalStrength)];
   self.attention.progress = attentionLevel;
   self.attentionPercent.text = [NSString stringWithFormat:@"%i%%", (int)(attentionLevel * 100)];
   self.meditation.progress = meditationLevel;
   self.meditationPercent.text = [NSString stringWithFormat:@"%i%%", (int)(meditationLevel * 100)];
   self.power.progress = powerLevel;
   self.powerPercent.text = [NSString stringWithFormat:@"%i%%", (int)(powerLevel * 100)];
   [self updateStatusImage:[self statusFromSignal:signalStrength power:powerLevel]];
   
   [self updateScores];
   
}

- (int) statusFromSignal: (float)signalLevel power:(float)powerLevel
{
   
   //   NSLog(@"signalLevel: %f | powerLevel: %f", signalLevel, powerLevel);
   
   if (signalLevel == 0.0) { // no signal
      return STATUS_CONNECTING;
   }
   
   if (signalLevel < 100.0) { // poor signal
      return STATUS_CONNECTED;
   }
   
   if (powerLevel == 0.0) { // strong signal but thresholds not met
      return STATUS_PROCESSING;
   } else { // flight command sent to orbit
      return STATUS_ACTIVE;
   }
   
}

- (void) notifyHeadsetConnect
{
   [self updateStatusImage:STATUS_CONNECTING];
}

- (void) notifyHeadsetDisconnect
{
   // Reset the outputs back to zero
   [self resetViews];
}

- (void) notifyDeviceConnected:(NSString *)name
{
   [self updateStatusImage:STATUS_CONNECTING];
   connectButton.title = @"Disconnect";
}

- (void) appStopped
{
   [self resetViews]; // just in case it didn't happen on close
}

#pragma mark - button press events

- (IBAction) connectButtonPressed:(id) sender {
   
   if (signalConverter.running) {
      [signalConverter stopProcessing];
      [self resetViews];
   } else {
      BOOL volumeMax  = [signalConverter isVolumeMax];
      BOOL headphones = [signalConverter isAudioJackPlugged];
      
      if (!warned && !volumeMax && !headphones) {
         UIAlertView *alert = [[UIAlertView alloc] initWithTitle:@"Check Volume & Transmitter" message:@"Ensure the volume is at max and the transmitter is plugged into the headphones" delegate:nil cancelButtonTitle:@"OK" otherButtonTitles: nil];
         [alert show];
      } else if (!warned && !volumeMax) {
         UIAlertView *alert = [[UIAlertView alloc] initWithTitle:@"Turn Up The Volume" message:@"Your device volume must be at the maximum for proper operation" delegate:nil cancelButtonTitle:@"OK" otherButtonTitles: nil];
         [alert show];
      } else if (!warned && !headphones) {
         UIAlertView *alert = [[UIAlertView alloc] initWithTitle:@"Plug In The Transmitter" message:@"Ensure the infrared transmitter is plugged into the headphone jack" delegate:nil cancelButtonTitle:@"OK" otherButtonTitles: nil];
         [alert show];
      } else if (!signalConverter.isBluetoothReady) {
         UIAlertView *alert = [[UIAlertView alloc] initWithTitle:@"Device not found" message:@"No Bluetooth device detected. Ensure Bluetooth is on and the Mindwave headset is paired" delegate:nil cancelButtonTitle:@"OK" otherButtonTitles: nil];
         [alert show];
      } else if ([signalConverter startProcessing]) {
         connectButton.title = @"Disconnect";
      } else {
         UIAlertView *alert = [[UIAlertView alloc] initWithTitle:@"Failed to connect" message:@"Check the device is correctly paired on Bluetooth" delegate:nil cancelButtonTitle:@"OK" otherButtonTitles: nil];
         [alert show];
      }
      warned = YES;
   }
}

- (IBAction) testButtonPressed:(id) sender {
   
   //   NSLog(@"Available fonts: %@", [UIFont familyNames]);
   
   [signalConverter isAudioJackPlugged];
   if (signalConverter.running) {
      UIAlertView *alert = [[UIAlertView alloc] initWithTitle:@"Signal Processing Active" message:@"Please press the Disconnect button before sending a Test signal" delegate:nil cancelButtonTitle:@"OK" otherButtonTitles: nil];
      [alert show];
   } else {
      if (signalConverter.testing) {
         testButton.title = @"Test";
         [signalConverter stopTestSound];
      } else {
         testButton.title = @"Stop";
         [signalConverter playTestSound];
      }
   }
}

- (void) updateScores
{
   
   //   /**
   //    * Score points based on target slider levels
   //    * If you pass your goal with either Attention or Meditation
   //    * the higher target of the two will counts as points per second.
   //    *
   //    * Minimum threshold for points is set as "minimumScoreTarget"
   //    *
   //    * For example, assume minimumScoreTarget is 40%.
   //    * If your target Attention is 60% and you go past to reach 80%
   //    * you will receive 20 points per second (60-40). If your
   //    * target is 80% and you reach 80% you will receive 40
   //    * points per second (80-40).
   //    *
   //    * You can set both Attention and Meditation targets at the
   //    * same time. Reaching either will fly the helicopter but you
   //    * will only receive points for the higher-scoring target of
   //    * the two.
   //    *
   //    */
   
   int eegAttentionScore = 0;
   int eegAttention = self.attention.progress * 100;
   int eegAttentionTarget = self.attentionThreshold.value * 100;
   
   int eegMeditationScore = 0;
   int eegMeditation = self.meditation.progress * 100;
   int eegMeditationTarget = self.meditationThreshold.value * 100;
   
   
   if ((eegAttention >= eegAttentionTarget) &&
       (eegAttentionTarget > minimumScoreTarget))
      eegAttentionScore = eegAttentionTarget - minimumScoreTarget;
   
   if ((eegMeditation >= eegMeditationTarget) &&
       (eegMeditationTarget > minimumScoreTarget))
      eegMeditationScore = eegMeditationTarget - minimumScoreTarget;
   
   if (eegAttentionScore > eegMeditationScore)
      scoreCurrent = scoreCurrent + eegAttentionScore;
   else
      scoreCurrent = scoreCurrent + eegMeditationScore;
   
   
   // High score
   if (scoreCurrent > scoreHigh) {
      scoreHigh = scoreCurrent;
   }
   
   // Reset score
   if (power.progress == 0)
      [self resetCurrentScore];
   
   
   // Catch anyone gaming the system with one slider
   // below the minimum threshold and the other over.
   // For example, setting Meditation to 1% will keep helicopter
   // activated even if Attention is below target
   if ((eegAttention < eegAttentionTarget) && (eegMeditation < minimumScoreTarget))
      [self resetCurrentScore];
   
   if ((eegMeditation < eegMeditationTarget) && (eegAttention < minimumScoreTarget))
      [self resetCurrentScore];
   
   if ((eegAttention < minimumScoreTarget) && (eegMeditation < minimumScoreTarget))
      [self resetCurrentScore];
   
   
   [self displayScore];
   
   
} // updateScore


// ################################################################

- (void) displayScore
{
   self.scoresDisplay.text = [NSString stringWithFormat:@"Scores        Current: %i    Last: %i    High: %i", (int)scoreCurrent, (int)scoreLast, (int)scoreHigh];
}

// ################################################################

- (void) resetCurrentScore
{
   if (scoreCurrent > 0)
      scoreLast = scoreCurrent;
   
   scoreCurrent = 0;
   
} // resetCurrentScore

@end