int main(int argc, char** argv) {
Aria::init();
//ArLog::init(ArLog::StdErr, ArLog::Verbose);
// Create the sound queue.
ArSoundsQueue soundQueue;
// Set WAV file callbacks
soundQueue.setPlayWavFileCallback(ArSoundPlayer::getPlayWavFileCallback());
soundQueue.setInterruptWavFileCallback(ArSoundPlayer::getStopPlayingCallback());
// Notifications when the queue goes empty or non-empty.
soundQueue.addQueueEmptyCallback(new ArGlobalFunctor(&queueNowEmpty));
soundQueue.addQueueNonemptyCallback(new ArGlobalFunctor(&queueNowNonempty));
// Run the sound queue in a new thread
soundQueue.runAsync();
// Get WAV file names from command line
if(argc < 2)
{
cerr << "Usage: " << argv[0] << " <up to ten WAV sound file names...>\n";
Aria::exit(-1);
}
std::vector<const char*> filenames;
for(int i = 1; i < min(argc, 11); i++)
{
filenames.push_back(argv[i]);
}
// This functor can be used to cancel all sound playback until removed
ArGlobalRetFunctor<bool> dontPlayItem(&no);
while(Aria::getRunning())
{
cout << "Queue is " <<
string(soundQueue.isPaused()?"paused":(soundQueue.isPlaying()?"playing":"ready"))
<< ", with " << soundQueue.getCurrentQueueSize() << " pending sounds." << endl
<< "Enter a command followed by the enter key:\n"
<< "\tp\trequest pause state (cumulative)\n"
<< "\tr\trequest resume state (cumulative)\n"
<< "\ti\tinterrupt current sound\n"
<< "\tc\tclear the queue\n"
<< "\tC\tclear priority < 4 from the queue.\n"
<< "\tn\tAdd " << filenames[0] << " to the queue, but with a condition callback to prevent it playing.\n"
<< "\tv\tAdjust volume -50%\n"
<< "\tV\tAdjust volume +50%\n"
<< "\to\tAdjust volume -100%\n"
<< "\tO\tAdjust volume +100%\n"
<< "\tl\tAdjust volume -200%\n"
<< "\tL\tAdjust volume +200%\n"
<< "\t-\tSet volume adjustment to normal level\n"
;
for(size_t i = 0; i < filenames.size(); i++)
cout << "\t" << i << "\tadd " << filenames[i] << " to the queue\n";
cout << "\tq\tquit\n\n";
int c = getchar();
if(c == '\n')
continue;
switch(c)
{
case 'p': soundQueue.pause(); break;
case 'r': soundQueue.resume(); break;
case 'i': soundQueue.interrupt(); break;
case 'q': soundQueue.stop(); ArUtil::sleep(100); Aria::exit(0);
case 'c': soundQueue.clearQueue(); break;
case 'C': soundQueue.removePendingItems(4); break;
case 'n':
{
cout << "Adding \"" << filenames[0] << "\" but with a condition callback that will prevent it from playing...\n";
ArSoundsQueue::Item item = soundQueue.createDefaultFileItem(filenames[0]);
item.playbackConditionCallbacks.push_back(&dontPlayItem);
soundQueue.addItem(item);
break;
}
case 'v': ArSoundPlayer::setVolumePercent(-50.0); break;
case 'V': ArSoundPlayer::setVolumePercent(50.0); break;
case 'o': ArSoundPlayer::setVolumePercent(-100.0); break;
case 'O': ArSoundPlayer::setVolumePercent(100.0); break;
case 'l': ArSoundPlayer::setVolumePercent(-200.0); break;
case 'L': ArSoundPlayer::setVolumePercent(200.0); break;
case '-': ArSoundPlayer::setVolumePercent(0.0); break;
default:
if(filenames.size() > 0 && c >= '0' && c <= '9')
{
size_t i = c - '0';
if(i < filenames.size())
{
cout << "Adding \"" << filenames[i] << "\" to the queue...\n";
soundQueue.play(filenames[i]);
}
}
}
}
cout << "ended.\n";
Aria::exit(0);
return 0;
}
int main(int argc, char **argv)
{
// Initialize Aria and Arnl global information
/* Aria initialization: */
Aria::init();
ArLog::init(ArLog::File, ArLog::Verbose,"c:\\temp\\AmbifluxRobot.log",true);
ArLog::log(ArLog::Verbose, "Ambiflux Starting");
// Create the sound queue.
ArSoundsQueue soundQueue;
// Set WAV file callbacks
soundQueue.setPlayWavFileCallback(ArSoundPlayer::getPlayWavFileCallback());
soundQueue.setInterruptWavFileCallback(ArSoundPlayer::getStopPlayingCallback());
// Notifications when the queue goes empty or non-empty.
soundQueue.addQueueEmptyCallback(new ArGlobalFunctor(&queueNowEmpty));
soundQueue.addQueueNonemptyCallback(new ArGlobalFunctor(&queueNowNonempty));
// Run the sound queue in a new thread
soundQueue.runAsync();
/* Pool de messages en provenance de la tablette
Issu de l'implementation d'un modèle producteur/consommateur
pour les messages entrants. Plusieurs thread y accèdent
Tread-safe (mutex)*/
//Pool<Frame> messagePool;
/* Pool de messages en provenance d'un client TCP
Issu de l'implementation d'un modèle producteur/consommateur
pour les messages entrants. Plusieurs thread y accèdent
Tread-safe (mutex)*/
/*TODO : A remplacer par tcpReceivedPool */
//Pool<Frame> tcpMessagePool;
/* Pool de messages en provenance d'un client TCP
Issu de l'implementation d'un modèle producteur/consommateur
pour les messages entrants. Plusieurs thread y accèdent
Tread-safe (mutex)*/
Pool<TCPReceivedRequest> tcpReceivedPool;
/*Create our thread to communicate with iPad
Server start on port 7171 to receive requests from ipad
A client is created on port 7474 to request iPad
*/
//IhmCommunicationThread ihm(7171, &messagePool);
IhmCommunicationThread ihm(7171, &tcpReceivedPool);
//On s'abonne à la réception de message par la classe IhmCommunicationThread
//Todo : A supprimer ?
//ArGlobalFunctor1<Frame> functMessageReceived(&CallbackIhmReceived);
//ihm.setCallback(&functMessageReceived);
ihm.runAsync();
//soundQueue.play("c:\\temp\\let_me_out.wav");
//while(true);
/* Create our client object. This is the object which connects with a remote
* server over the network, and which manages all of our communication with it
* once connected by sending data "requests". Requests may be sent once, or
* may be repeated at any frequency. Requests and replies to requsets contain
* payload "packets", into which various data types may be packed (when making a
* request), and from which they may also be extracted (when handling a reply).
* See the InputHandler and OutputHandler classes above for
* examples of making requests and reading/writing the data in packets.
*/
ArClientBase client;
/* Aria components use this to get options off the command line: */
ArArgumentParser parser(&argc, argv);
/* This will be used to connect our client to the server, including
* various bits of handshaking (e.g. sending a password, retrieving a list
* of data requests and commands...)
* It will get the hostname from the -host command line argument: */
ArClientSimpleConnector clientConnector(&parser);
parser.loadDefaultArguments();
/* Check for -help, and unhandled arguments: */
if (!Aria::parseArgs() || !parser.checkHelpAndWarnUnparsed())
{
Aria::logOptions();
exit(0);
}
/* Connect our client object to the remote server: */
if (!clientConnector.connectClient(&client))
{
if (client.wasRejected())
printf("Server '%s' rejected connection, exiting\n", client.getHost());
else
printf("Could not connect to server '%s', exiting\n", client.getHost());
exit(1);
}
printf("Connected to server.\n");
client.setRobotName(client.getHost()); // include server name in log messages
///* Create a key handler and also tell Aria about it */
ArKeyHandler keyHandler;
Aria::setKeyHandler(&keyHandler);
/* Global escape-key handler to shut everythnig down */
ArGlobalFunctor escapeCB(&escape);
keyHandler.addKeyHandler(ArKeyHandler::ESCAPE, &escapeCB);
/* Now that we're connected, we can run the client in a background thread,
* sending requests and receiving replies. When a reply to a request arrives,
* or the server makes a request of the client, a handler functor is invoked.
* The handlers for this program are registered with the client by the
* InputHandler and OutputHandler classes (in their constructors, above) */
client.runAsync();
///* Create the InputHandler object and request safe-drive mode */
//InputHandler inputHandler(&client);
//inputHandler.gotoGoal("215");
////inputHandler.safeDrive();
// Mode goto
if(!client.dataExists("gotoGoal") )
printf("Warning: Pas de mode goto!\n");
else
printf("Mode goto accepte");
//ArFunctor1<ArNetPacket*>
//client.addHandler("pathPlannerStatus",);
/* Create the OutputHandler object. It will begin printing out data from the
* server. */
OutputHandler outputHandler(&client);
//On s'abonne à la réception de message par la classe IhmCommunicationThread
//Todo : A supprimer ?
//ArGlobalFunctor1<Frame> functMessageReceived(&CallbackIhmReceived);
//ihm.setCallback(&functMessageReceived);
//ihm.runAsync();
//pour tester IHM
// ArUtil::sleep(1000);
// ihm.testCommunication();
//SRMA object
string strSRMA = DALRest::getResourceById("9");
SRMA srma(strSRMA,client, outputHandler, ihm, &soundQueue);
//Loop du mode Ambiant
MainLoop myLoop(srma, &tcpReceivedPool);
myLoop.runAsync();
//Thread loop : TCP commands
//Produces messages in tcpMessagePool
//ServerLoop myServerLoop(srma, &tcpReceivedPool);
//myServerLoop.runAsync();
//Traitement des requetes TCP
//Consulmes messages in tcpMessagePool
//TCPRequestsLoop myTCPRequestsLoop(srma, &tcpReceivedPool);
//myTCPRequestsLoop.runAsync();
/* While the client is still running (getRunningWithLock locks the "running"
* flag until it returns), check keys on the key handler (which will call
* our callbacks), then tell the input handler to send drive commands.
* Sleep a fraction of a second as well to avoid using
* too much CPU time, and give other threads time to work.
*/
while (client.getRunningWithLock())
{
//keyHandler.checkKeys();
//inputHandler.sendInput();
ArUtil::sleep(100);
}
/* The client stopped running, due to disconnection from the server, general
* Aria shutdown, or some other reason. */
client.disconnect();
Aria::shutdown();
return 0;
}
