Add polling and audio check to copresence.

components/copresence/handlers/directive_handler.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/copresence/handlers/directive_handler.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/time/time.h"
 #include "components/copresence/handlers/audio/audio_directive_handler_impl.h"
 #include "components/copresence/proto/data.pb.h"
 
 namespace copresence {
 
 // Public functions
 
 DirectiveHandler::DirectiveHandler()
-  : audio_handler_(new AudioDirectiveHandlerImpl),
-    whispernet_client_(nullptr) {}
+    : audio_handler_(new AudioDirectiveHandlerImpl), is_started_(false) {
+}
 
 DirectiveHandler::~DirectiveHandler() {}
 
-void DirectiveHandler::Start(WhispernetClient* whispernet_client) {
+void DirectiveHandler::Start(WhispernetClient* whispernet_client,
+                             const TokensCallback& tokens_cb) {
   DCHECK(whispernet_client);
-  whispernet_client_ = whispernet_client;
+  audio_handler_->Initialize(whispernet_client, tokens_cb);
 
-  // TODO(ckehoe): Just pass Whispernet all the way down to the AudioManager.
-  //               We shouldn't be concerned with these details here.
-  audio_handler_->Initialize(
-      base::Bind(&WhispernetClient::DecodeSamples,
-                 base::Unretained(whispernet_client_)),
-      base::Bind(&DirectiveHandler::EncodeToken,
-                 base::Unretained(this)));
+  is_started_ = true;
 
   // Run all the queued directives.
   for (const auto& op_id : pending_directives_) {
-    for (const Directive& directive : op_id.second) {
+    for (const Directive& directive : op_id.second)
       StartDirective(op_id.first, directive);
-    }
   }
   pending_directives_.clear();
 }
 
 void DirectiveHandler::AddDirective(const Directive& directive) {
   // We only handle transmit and receive directives.
   // WiFi and BLE scans aren't implemented.
   DCHECK_EQ(directive.instruction_type(), TOKEN);
 
   std::string op_id;
   if (directive.has_published_message_id()) {
     op_id = directive.published_message_id();
   } else if (directive.has_subscription_id()) {
     op_id = directive.subscription_id();
   } else {
     NOTREACHED() << "No operation associated with directive!";
     return;
   }
 
-  if (!whispernet_client_) {
+  if (!is_started_) {
     pending_directives_[op_id].push_back(directive);
   } else {
     StartDirective(op_id, directive);
   }
 }
 
 void DirectiveHandler::RemoveDirectives(const std::string& op_id) {
   // If whispernet_client_ is null, audio_handler_ hasn't been Initialized.
-  if (whispernet_client_) {
+  if (is_started_) {
     audio_handler_->RemoveInstructions(op_id);
   } else {
     pending_directives_.erase(op_id);
   }
 }
 
 const std::string DirectiveHandler::GetCurrentAudioToken(AudioType type) const {
   // If whispernet_client_ is null, audio_handler_ hasn't been Initialized.
-  return whispernet_client_ ? audio_handler_->PlayingToken(type) : "";
+  return is_started_ ? audio_handler_->PlayingToken(type) : "";
 }
 
+bool DirectiveHandler::IsAudioTokenHeard(AudioType type) const {
+  return is_started_ ? audio_handler_->IsPlayingTokenHeard(type) : false;
+}
 
 // Private functions
 
 void DirectiveHandler::StartDirective(const std::string& op_id,
                                       const Directive& directive) {
   const TokenInstruction& ti = directive.token_instruction();
   if (ti.medium() == AUDIO_ULTRASOUND_PASSBAND ||
       ti.medium() == AUDIO_AUDIBLE_DTMF) {
     audio_handler_->AddInstruction(
         ti, op_id, base::TimeDelta::FromMilliseconds(directive.ttl_millis()));
   } else {
     // We should only get audio directives.
     NOTREACHED() << "Received directive for unimplemented medium "
                  << ti.medium();
   }
 }
 
-// TODO(ckehoe): We don't need to re-register the samples callback
-// every time. Which means this whole function is unnecessary.
-void DirectiveHandler::EncodeToken(
-    const std::string& token,
-    AudioType type,
-    const WhispernetClient::SamplesCallback& samples_callback) {
-  DCHECK(type == AUDIBLE || type == INAUDIBLE);
-  // TODO(ckehoe): This null check shouldn't be necessary.
-  // It's only here for tests.
-  if (whispernet_client_) {
-    whispernet_client_->RegisterSamplesCallback(samples_callback);
-    whispernet_client_->EncodeToken(token, type);
-  }
-}
-
 }  // namespace copresence