ArServerMode.h

Go to the documentation of this file.

/*
MobileRobots Advanced Robotics Interface for Applications (ARIA)
Copyright (C) 2004, 2005 ActivMedia Robotics LLC
Copyright (C) 2006, 2007 MobileRobots Inc.

     This program 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.

     This program 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 Place, Suite 330, Boston, MA  02111-1307  USA

If you wish to redistribute ARIA under different terms, contact 
MobileRobots for information about a commercial version of ARIA at 
robots@mobilerobots.com or 
MobileRobots Inc, 19 Columbia Drive, Amherst, NH 03031; 800-639-9481
*/

#ifndef ARSERVERMODE_H
#define ARSERVERMODE_H

#include "Aria.h"
#include "ArServerBase.h"

class ArServerClient;


class ArServerMode
{
public:
  AREXPORT ArServerMode(ArRobot *robot, ArServerBase *server, const char *name);
  AREXPORT virtual ~ArServerMode();
  AREXPORT virtual ArActionGroup *getActionGroup(void) { return NULL; }
  AREXPORT virtual void activate(void) = 0;
  AREXPORT virtual void deactivate(void) = 0;
  AREXPORT virtual void userTask(void) {}
  AREXPORT virtual void requestUnlock(void) { }
  AREXPORT void lockMode(bool willUnlockIfRequested = false);
  AREXPORT void unlockMode(void);      
  AREXPORT const char *getMode(void) const { return myMode.c_str(); }
  AREXPORT const char *getStatus(void) const { return myStatus.c_str(); }
  AREXPORT const char *getName(void) const { return myName.c_str(); }
  AREXPORT bool isActive(void) const { return myIsActive; }
  AREXPORT static bool willUnlockIfRequested(void);
  AREXPORT static ArServerMode *getActiveMode(void);
  AREXPORT bool hasSetActivityTime(void) { return myHasSetActivityTime; }
  AREXPORT ArTime getActivityTime(void);
  AREXPORT void setActivityTimeToNow(void);
  AREXPORT static int getActiveModeActivityTimeSecSince(void);
  AREXPORT void addAsDefaultMode(ArListPos::Pos pos = ArListPos::LAST);

  AREXPORT virtual void checkDefault(void) {}
  AREXPORT void setMode(const char *str) { myMode = str; }

  AREXPORT void setStatus(const char *str) 
    { myStatus = str; myStatusSetThisCycle = true; }
  AREXPORT bool addModeData(
          const char *name, const char *description,
          ArFunctor2<ArServerClient *, ArNetPacket *> *functor,
          const char *argumentDescription, const char *returnDescription,
          const char *commandGroup = NULL, const char *dataFlags = NULL);
  AREXPORT static void getModeDataList(ArServerClient *client, 
                                       ArNetPacket *packet);
  AREXPORT static void getModeInfo(ArServerClient *client, 
                                   ArNetPacket *packet);
  AREXPORT void addActivateCallback(
          ArFunctor *functor, ArListPos::Pos position = ArListPos::LAST) 
    { myActivateCallbacks.addCallback(functor, position); }
  AREXPORT void remActivateCallback(ArFunctor *functor)
    { myActivateCallbacks.remCallback(functor); }
  AREXPORT void addDeactivateCallback(
          ArFunctor *functor, ArListPos::Pos position = ArListPos::LAST) 
    { myDeactivateCallbacks.addCallback(functor, position); }
  AREXPORT void remDeactivateCallback(ArFunctor *functor)
    { myDeactivateCallbacks.remCallback(functor); }
protected:
  AREXPORT static void modeUserTask(void);
  AREXPORT static void buildModeInfoPacket(ArNetPacket *packet);
  AREXPORT static std::list<ArServerMode *> *getRequestedActivateModes(void);
  AREXPORT void checkBroadcastModeInfoPacket(void);
  AREXPORT bool baseActivate(void);
  AREXPORT void baseDeactivate(void);

  ArCallbackList myActivateCallbacks;
  ArCallbackList myDeactivateCallbacks;

  bool myIsActive;
  ArRobot *myRobot;
  ArServerBase *myServer;
  std::string myName;
  // inheritors will want to play with these two strings as they are
  // what is shown to the user
  std::string myMode;
  std::string myStatus;
  bool myStatusSetThisCycle;

  // variables for activity time (so we can do things if idle) this
  // isn't static so that each mode can have its own
  // 'myHasSetActivityTime' so that if a mode doesn't use this scheme
  // it doesn't get tromped on
  bool myHasSetActivityTime;
  ArTime myActivityTime;
  ArMutex myActivityTimeMutex;
  
  AREXPORT static bool ourActiveModeLocked;
  AREXPORT static bool ourActiveModeWillUnlockIfRequested;
  AREXPORT static ArServerMode *ourActiveMode;
  AREXPORT static ArServerMode *ourNextActiveMode;
  AREXPORT static std::list<ArServerMode *> ourModes;
  AREXPORT static std::list<ArServerMode *> ourDefaultModes;
  AREXPORT static std::list<ArServerMode *> ourRequestedActivateModes;
  AREXPORT static std::multimap<std::string, std::string> ourModeDataMap;
  AREXPORT static ArMutex ourModeDataMapMutex;
  AREXPORT static ArGlobalFunctor2<ArServerClient *, 
                                   ArNetPacket *> ourGetModeDataListCB;
  AREXPORT static ArGlobalFunctor2<ArServerClient *, 
                                   ArNetPacket *> ourGetModeInfoCB;
  AREXPORT static bool ourLastActiveModeLocked;
  AREXPORT static ArServerMode *ourLastActiveMode;
  AREXPORT static bool ourLastActiveModeWillUnlockIfRequested;
  static ArGlobalFunctor ourUserTaskCB;    
  static bool ourUserTaskAdded;  
  // so we can easily just get the verbose out of this one
  ArLog::LogLevel myVerboseLogLevel;
};

#endif // ARSERVERMODE_H

---