ACE/examples/APG/Streams/RecordingDevice.h

   1 /* -*- C++ -*- */
   2 #ifndef RECORDING_DEVICE_H
   3 #define RECORDING_DEVICE_H
   4
   5 #include "ace/FILE_Addr.h"
   6 #include "ace/Event_Handler.h"
   7 #include "ace/Log_Msg.h"
   8 #include "ace/Reactor.h"
   9 #include "ace/Semaphore.h"
  10
  11 class CallerId;
  12 class MessageType;
  13
  14 class RecordingDevice
  15 {
  16 public:
  17   RecordingDevice ()
  18   {
  19     // Initialize the semaphore so that we don't block on the
  20     // first call to wait_for_activity().
  21   }
  22
  23   virtual ~RecordingDevice ()
  24   {
  25   }
  26
  27   virtual const ACE_TCHAR *get_name () const
  28   {
  29     return ACE_TEXT ("UNKNOWN");
  30   }
  31
  32   virtual int init (int, ACE_TCHAR *[])
  33   {
  34     return 0;
  35   }
  36
  37   // Answer the incoming call
  38   virtual int answer_call () = 0;
  39
  40   // Fetch some form of caller identification at the hardware level.
  41   virtual CallerId *retrieve_callerId () = 0;
  42
  43   // Fetch the message at the location specified by 'addr' and play
  44   // it for the caller.
  45   virtual int play_message (ACE_FILE_Addr &addr) = 0;
  46
  47   // Record data from our physical device into the file at the
  48   // specified address. Return the number of bytes recorded.
  49   virtual MessageType *record_message (ACE_FILE_Addr &addr) = 0;
  50
  51   // Release the RecordingDevice to accept another incoming call
  52   virtual void release ()
  53   {
  54     this->release_semaphore ();
  55   }
  56
  57   // Get the handler of the device so that wait_for_activity() can
  58   // wait for data to arrive.
  59   virtual ACE_Event_Handler *get_handler () const
  60   {
  61     return 0;
  62   }
  63
  64   virtual RecordingDevice *wait_for_activity ()
  65   {
  66     // Block on a semaphore until it says we're ready to do
  67     // work.
  68     ACE_DEBUG ((LM_DEBUG,
  69                 ACE_TEXT ("Waiting for semaphore\n")));
  70     this->acquire_semaphore ();
  71
  72     // Use the reactor to wait for activity on our handle
  73     ACE_Reactor reactor;
  74
  75     ACE_Event_Handler *handler = this->get_handler ();
  76     ACE_DEBUG ((LM_DEBUG,
  77                 ACE_TEXT ("Handler is %@\n"),
  78                 (void *)handler));
  79
  80     reactor.register_handler (this->get_handler (),
  81                               ACE_Event_Handler::READ_MASK);
  82
  83     reactor.handle_events ();
  84     // Error-check this...
  85
  86     // Leave the semaphore locked so that we'll block until
  87     // recording_complete() is invoked.
  88
  89     return this;
  90   }
  91
  92 protected:
  93   void acquire_semaphore ()
  94   {
  95     this->semaphore_.acquire ();
  96   }
  97
  98   void release_semaphore ()
  99   {
 100     // Reset the semaphore so that wait_for_activity() will
 101     // unblock.
 102     ACE_DEBUG ((LM_DEBUG,
 103                 ACE_TEXT ("Releasing semaphore\n")));
 104     this->semaphore_.release ();
 105   }
 106
 107 private:
 108   ACE_Semaphore semaphore_;
 109 };
 110
 111 #include "RecordingDevice_Text.h"
 112 #include "RecordingDevice_USRVM.h"
 113 #include "RecordingDevice_QC.h"
 114
 115 #include "RecordingDeviceFactory.h"
 116
 117 #endif /* RECORDING_DEVICE_H */