MABehaviorManager.cpp

/*
 *  This file is part of the AiBO+ project
 *
 *  Copyright (C) 2005-2016 Csaba Kertész (csaba.kertesz@gmail.com)
 *
 *  AiBO+ is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  AiBO+ is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Street #330, Boston, MA 02111-1307, USA.
 *
 */

#include "MABehaviorManager.hpp"

#include "core/MAMicrophoneDevice.hpp"
#include "types/skits/MASkitDatabase.hpp"
#include "sound/MASoundDatabase.hpp"
#include "controllers/MAController.hpp"
#include "ml/MAClassifierModels.hpp"
#include "ml/MADataCollector.hpp"
#include "MABatteryStatus.hpp"
#include "MABodyAngry.hpp"
#include "MABodyAwaking.hpp"
#include "MABodyHappy.hpp"
#include "MABodyPoked.hpp"
#include "MABodyStateMaster.hpp"
#include "MABodySleeping.hpp"
#include "MABodyStroked.hpp"
#include "MAChangeEyePupil.hpp"
#include "MAClientConnected.hpp"
#include "MADataUploadStatus.hpp"
#include "MAEyePupil.hpp"
#include "MAHeadLookAroundMaster.hpp"
#include "MAHeavyCalculations.hpp"
#include "MASkitterPlaybackMaster.hpp"
#include "MAMouthSpeakingMaster.hpp"
#include "MANoWritableStorage.hpp"
#include "MANumberGameMaster.hpp"
#include "MAHeadTurnMaster.hpp"
#include "MASoundEventMaster.hpp"
#include "MASpeakerVolume.hpp"
#include "MAStartUp.hpp"
#include "MASwitchSoundProfile.hpp"
#include "MASwitchVolumeControl.hpp"
#include "numbergame/MANumberGameMaster.hpp"

#include <MCLog.hpp>
#include <MCTimer.hpp>

namespace MA
{
MCThreadLocalData<MABehaviorManager> BehaviorManager(false);
MCThreadLocalData<MAClassifierModels> ClassifierModels(true);
}

MABehaviorManager::MABehaviorManager() : Verbose(false)
{
  if (MA::BehaviorManager.get())
  {
    MC_WARNING("The global behavior manager is overridden.");
  }
  MA::BehaviorManager.reset(this);
  if (!MA::DataCollector.get())
  {
    MA::DataCollector.reset(new MADataCollector);
  }
  if (!MA::ClassifierModels.get())
  {
    MA::ClassifierModels.reset(new MAClassifierModels);
  }
}


MABehaviorManager::~MABehaviorManager()
{
  if (MA::BehaviorManager.get() == this)
  {
    MA::BehaviorManager.release();
  }
  MABehavior::Cleanup();
  if (MA::SkitDatabase.get())
  {
    MA::SkitDatabase.reset(nullptr);
  }
  if (MA::SoundDatabase.get())
  {
    MA::SoundDatabase.reset(nullptr);
  }
  if (MA::DataCollector.get())
  {
    MA::DataCollector.reset(nullptr);
  }
  if (MA::ClassifierModels.get())
  {
    MA::ClassifierModels.reset(nullptr);
  }
}


void MABehaviorManager::SetVerbose(bool new_state)
{
  Verbose = new_state;
}


void MABehaviorManager::UpdateBehaviors()
{
  // Clean behavior state events
  MABehavior::ClearBehaviorStateEvents();
  // Let's create the behaviors here so we can make sure the initialization is done
  // on the devices/controllers side.
  if (MABehavior::GetBehaviors().empty() && !MABehavior::IsMergeNeeded())
  {
    CreateDefaultBehaviors();
  }
  MA::BehaviorList ProposedBehaviors;

  // Merge the new behaviors to the global list
  if (Verbose)
  {
    MC_LOG("Merge the new behaviors to the global list");
  }
  MABehavior::MergeNewBehaviors();

  // Calculate and circulate the activations
  if (Verbose)
  {
    MC_LOG("Calculate and circulate the activations");
  }
  MABehavior::CalculateActivations();

  // Create the list of the proposed behavior list
  if (Verbose)
  {
    MC_LOG("Create the list of the proposed behavior list");
  }
  const MA::BehaviorList& Behaviors = MABehavior::GetBehaviors();

  for (auto& behavior : Behaviors)
  {
    // The behavior has not been active before and it has the highest activation
    if (behavior->GetState() != MABehavior::Failed &&
        behavior->GetState() != MABehavior::Finished &&
        behavior->GetActivationLevel() == 100)
    {
      ProposedBehaviors.push_back(behavior);
    }
  }

  // Execute the final behaviors
  if (Verbose)
  {
    MC_LOG("Execute the final behaviors");
  }
  for (auto& behavior : ProposedBehaviors)
  {
    // Handle the case when a behavior is deleted during the activation of an other behavior
    if (!MABehavior::Exists(behavior.get()))
      continue;

    // The behavior has not been active before
    if (behavior->GetState() != MABehavior::Activated)
      ActiveBehaviors.push_back(behavior);

    behavior->SetState(MABehavior::Activated);
  }

  // Remove the dirty behaviors (self-destroy)
  if (Verbose)
  {
    MC_LOG("Remove the finished/failed behaviors (self-destroy)");
  }
  MABehavior::GarbageCollection();

  // Remove the finished and failed behaviors
  if (Verbose)
  {
    MC_LOG("Remove the finished or deleted behaviors");
  }
  for (auto iter = ActiveBehaviors.begin(); iter != ActiveBehaviors.end();)
  {
    if ((*iter)->GetState() != MABehavior::Activated)
    {
      iter = ActiveBehaviors.erase(iter);
      // This safety check is required otherwise crash
      if (iter == ActiveBehaviors.end())
      {
        break;
      }
      continue;
    }
    ++iter;
  }
  // Remove dirty activated behaviors
  for (auto iter = ActiveBehaviors.begin(); iter != ActiveBehaviors.end();)
  {
    if (!MABehavior::Exists(iter->get()))
    {
      iter = ActiveBehaviors.erase(iter);
      // This safety check is required otherwise crash
      if (iter == ActiveBehaviors.end())
      {
        break;
      }
      continue;
    }
    ++iter;
  }
  // Update the data collector
  MA::DataCollector->UpdateJobs();
}


void MABehaviorManager::SetRandomSeed()
{
  MCRandomSeed::SetNewSeed();
}


void MABehaviorManager::HibernateSystem()
{
  MCTimer::HibernateSystemTime();
}


void MABehaviorManager::ResumeSystem()
{
  MCTimer::ResumeSystemTime();
  if (MA::Microphone.get())
    MA::Microphone->ResetListening();
}


std::string MABehaviorManager::GetSkitDatabaseFileName()
{
#if !defined(__AIBO_BUILD__)
  return MCGetDataFile("skits.db").toStdString();
#else
  return "";
#endif
}


std::string MABehaviorManager::GetSoundDatabaseFileName()
{
#if !defined(__AIBO_BUILD__)
  return MCGetDataFile("sounds.db").toStdString();
#else
  return "";
#endif
}


void MABehaviorManager::CreateDefaultBehaviors()
{
  // Prevent to create the behaviors twice or more
  if (!MABehavior::GetBehaviors().empty() || MABehavior::IsMergeNeeded())
    return;

  // Do initialization steps
  SetRandomSeed();
  if (!MA::SkitDatabase.get())
  {
    MA::SkitDatabase.reset(MASkitDatabase::LoadFromFile(GetSkitDatabaseFileName()));
    MA::SkitDatabase->CreateMirroredSkits();
  }
  if (!MA::SoundDatabase.get())
  {
    MA::SoundDatabase.reset(MASoundDatabase::LoadFromFile(GetSoundDatabaseFileName()));
  }
  // Create the default behaviors
  MACreateBehavior<MABatteryStatus>(nullptr);
  MACreateBehavior<MADataUploadStatus>(nullptr);
  // TODO: We don't need writable memory stick yet...
//  MACreateBehavior<MANoWritableStorage>(NULL);
  MACreateBehavior<MAStartUp>(nullptr);
  MACreateBehavior<MABodyAngry>(nullptr);
  MACreateBehavior<MABodyHappy>(nullptr);
  MACreateBehavior<MABodyPoked>(nullptr);
  MACreateBehavior<MABodyAwaking>(nullptr);
  MACreateBehavior<MABodySleeping>(nullptr);
  MACreateBehavior<MABodyStroked>(nullptr);
  MACreateBehavior<MAEyePupil>(nullptr);
  MACreateBehavior<MAHeadLookAroundMaster>(nullptr);
  MACreateBehavior<MAHeadTurnMaster>(nullptr);
  MACreateBehavior<MASpeakerVolume>(nullptr);
  MACreateBehavior<MASwitchSoundProfile>(nullptr);
  MACreateBehavior<MASwitchVolumeControl>(nullptr);
  MACreateBehavior<MAMouthSpeakingMaster>(nullptr);
  MACreateBehavior<MABodyStateMaster>(nullptr);
  MACreateBehavior<MASkitterPlaybackMaster>(nullptr);
  MACreateBehavior<MAHeavyCalculations>(nullptr);
  MACreateBehavior<MAClientConnected>(nullptr);
  MACreateBehavior<MANumberGameMaster>(nullptr);
  MACreateBehavior<MASoundEventMaster>(nullptr);
  MACreateBehavior<MAChangeEyePupil>(nullptr);
}