source: trunk/Cocoa/F-Script Anywhere/Source/SCPatch/Common/SCPatchMessenger.h@ 653

#pragma once

extern "C" 
{
#include <pthread.h> 
}

#include <CoreFoundation/CoreFoundation.h> 
#include "SCPatchCommon.h"
#include "SCPatchMessages.h"

#define DEFAULT_MESSAGE_RETRY_LIMIT             100     // Give up after 5 seconds
#define DEFAULT_MESSAGE_RETRY_INTERVAL  .05

// These AppleEvents get sent to ReceiveMessage after StartListening and
// before StopListening, respectively.
const OSType    kEventClassSCPatchMessenger = 'SCPm';
const OSType    kEventSCPatchStart                      = 'strt';
const OSType    kEventSCPatchStop                       = 'stop';

typedef struct
{
        Boolean                         threaded;
        UInt32                          retryCount;
        Ptr                                     descData;
        UInt32                          descSize;
        CFStringRef                     portName;
} AEMessageInfo;


class SCPatchMessenger
{

  public:
    SCPatchMessenger(void);
    virtual ~SCPatchMessenger(void);
    
    void                                SetMessageRetryInterval(float interval) { mMessageRetryInterval = interval; }
    float                               GetMessageRetryInterval(void) { return mMessageRetryInterval; }
    
    void                                SetMessageRetryLimit(UInt32 limit) { mMessageRetryLimit = limit; }
    UInt32                              GetMessageRetryLimit(void) { return mMessageRetryLimit; }
    
    // Start listening for messages.  If called from a patch, a PSN must be supplied.
    // When called from a controller, pass NULL for the PSN.
    OSErr                               StartListening(CFStringRef myBundleIdentifier, 
                                                        Boolean isPatch, Boolean threaded);
    OSErr                               StopListening(void);
    
    // When sending from controller to patch, you have to include the PSN to disambiguate
    // the bundleID (because the same bundle is loaded into multiple apps), but when 
    // sending from patch back to controller, the PSN can be null, since there's only one
    // controller running.
        OSErr                           SendPing(CFStringRef bundleIdentifier, ProcessSerialNumber *psn);

        OSErr                           SendMessage(CFStringRef bundleIdentifier,
                                                        ProcessSerialNumber *psn,
                                                        AEEventClass evtClass, AEEventID evtID,
                                                        const char *paramsFmt, ...);

        OSErr                           SendMessage(CFStringRef bundleIdentifier, 
                                                        ProcessSerialNumber *psn, 
                                                        const AppleEvent *theAE,
                                                        Boolean threaded);
                                                        
        // Override this to receive messages.
        virtual void            ReceiveMessage(const AppleEvent *theAE) = 0;
        
  protected:
        virtual OSErr           HandleMessage(const AppleEvent *) { return eventNotHandledErr; }
        
  private:
        // Info for the listening port
        CFMessagePortRef        mMessagePort;
        CFRunLoopSourceRef      mMessageSource;
        
        // Flags for whether we queue outgoing messages, and whether sending is threaded.
        Boolean                         mThreaded;
        
        // We have named send queues, where the key is the port name.
        // Each queue is a CFArray of messages.
        CFMutableDictionaryRef  mMessageQueueDict;
        CFMutableDictionaryRef  mMessageThreadDict;
        
        pthread_mutex_t         mMessageQueueMutex;
        float                           mMessageRetryInterval;
        UInt32                          mMessageRetryLimit;
        
        OSErr                           SendMessage(AEMessageInfo *info);
        static void             *SendThreadEntryPoint(void *infoPtr);
        OSErr                           QueueMessage(AEMessageInfo *info);
        AEMessageInfo           *GetNextMessage(pthread_t threadID);
        AEMessageInfo           *DequeueMessage(pthread_t threadID);
        
        static CFDataRef        ReceiveCallback(CFMessagePortRef local, SInt32 message, CFDataRef dataRef, void *info);
};