/************************************************************************************ PublicHeader: n/a Filename : OVR_RPC1.h Content : A network plugin that provides remote procedure call functionality. Created : June 10, 2014 Authors : Kevin Jenkins Copyright : Copyright 2014 Oculus VR, Inc. All Rights reserved. Licensed under the Oculus VR Rift SDK License Version 3.1 (the "License"); you may not use the Oculus VR Rift SDK except in compliance with the License, which is provided at the time of installation or download, or which otherwise accompanies this software in either electronic or hard copy form. You may obtain a copy of the License at http://www.oculusvr.com/licenses/LICENSE-3.1 Unless required by applicable law or agreed to in writing, the Oculus VR SDK distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ************************************************************************************/ #ifndef OVR_Net_RPC_h #define OVR_Net_RPC_h #include "OVR_NetworkPlugin.h" #include "../Kernel/OVR_Hash.h" #include "../Kernel/OVR_String.h" #include "OVR_BitStream.h" #include "../Kernel/OVR_Threads.h" #include "../Kernel/OVR_Delegates.h" #include "../Kernel//OVR_Observer.h" namespace OVR { namespace Net { namespace Plugins { typedef Delegate3 RPCDelegate; typedef Delegate2 RPCSlot; // typedef void ( *Slot ) ( OVR::Net::BitStream *userData, OVR::Net::ReceivePayload *pPayload ); /// NetworkPlugin that maps strings to function pointers. Can invoke the functions using blocking calls with return values, or signal/slots. Networked parameters serialized with BitStream class RPC1 : public NetworkPlugin { public: RPC1(); virtual ~RPC1(); /// Register a slot, which is a function pointer to one or more implementations that supports this function signature /// When a signal occurs, all slots with the same identifier are called. /// \param[in] sharedIdentifier A string to identify the slot. Recommended to be the same as the name of the function. /// \param[in] functionPtr Pointer to the function. /// \param[in] callPriority Slots are called by order of the highest callPriority first. For slots with the same priority, they are called in the order they are registered void RegisterSlot(OVR::String sharedIdentifier, OVR::Observer *rpcSlotObserver); /// \brief Same as \a RegisterFunction, but is called with CallBlocking() instead of Call() and returns a value to the caller bool RegisterBlockingFunction(OVR::String uniqueID, RPCDelegate blockingFunction); /// \brief Same as UnregisterFunction, except for a blocking function void UnregisterBlockingFunction(OVR::String uniqueID); // \brief Same as call, but don't return until the remote system replies. /// Broadcasting parameter does not exist, this can only call one remote system /// \note This function does not return until the remote system responds, disconnects, or was never connected to begin with /// \param[in] Identifier originally passed to RegisterBlockingFunction() on the remote system(s) /// \param[in] bitStream bitStream encoded data to send to the function callback /// \param[in] pConnection connection to send on /// \param[out] returnData Written to by the function registered with RegisterBlockingFunction. /// \return true if successfully called. False on disconnect, function not registered, or not connected to begin with bool CallBlocking( OVR::String uniqueID, OVR::Net::BitStream * bitStream, Ptr pConnection, OVR::Net::BitStream *returnData = NULL ); /// Calls zero or more functions identified by sharedIdentifier registered with RegisterSlot() /// \param[in] sharedIdentifier parameter of the same name passed to RegisterSlot() on the remote system /// \param[in] bitStream bitStream encoded data to send to the function callback /// \param[in] pConnection connection to send on bool Signal(OVR::String sharedIdentifier, OVR::Net::BitStream * bitStream, Ptr pConnection); void BroadcastSignal(OVR::String sharedIdentifier, OVR::Net::BitStream * bitStream); protected: virtual void OnReceive(ReceivePayload *pPayload, ListenerReceiveResult *lrrOut); virtual void OnDisconnected(Connection* conn); virtual void OnConnected(Connection* conn); Hash< String, RPCDelegate, String::HashFunctor > registeredBlockingFunctions; ObserverHash< RPCSlot > slotHash; // Synchronization for RPC caller Lock singleRPCLock; Mutex callBlockingMutex; WaitCondition callBlockingWait; Net::BitStream* blockingReturnValue; Ptr blockingOnThisConnection; }; }}} // OVR::Net::Plugins #endif // OVR_Net_RPC_h