llmediadataclient.h
上传用户:king477883
上传日期:2021-03-01
资源大小:9553k
文件大小:11k
源码类别:

游戏引擎

开发平台:

C++ Builder

  1. /** 
  2.  * @file llmediadataclient.h
  3.  * @brief class for queueing up requests to the media service
  4.  *
  5.  * $LicenseInfo:firstyear=2007&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2007-2010, Linden Research, Inc.
  8.  * 
  9.  * Second Life Viewer Source Code
  10.  * The source code in this file ("Source Code") is provided by Linden Lab
  11.  * to you under the terms of the GNU General Public License, version 2.0
  12.  * ("GPL"), unless you have obtained a separate licensing agreement
  13.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  14.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  15.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  16.  * 
  17.  * There are special exceptions to the terms and conditions of the GPL as
  18.  * it is applied to this Source Code. View the full text of the exception
  19.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  20.  * online at
  21.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  22.  * 
  23.  * By copying, modifying or distributing this software, you acknowledge
  24.  * that you have read and understood your obligations described above,
  25.  * and agree to abide by those obligations.
  26.  * 
  27.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  28.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  29.  * COMPLETENESS OR PERFORMANCE.
  30.  * $/LicenseInfo$
  31.  */
  32. #ifndef LL_LLMEDIADATACLIENT_H
  33. #define LL_LLMEDIADATACLIENT_H
  34. #include "llhttpclient.h"
  35. #include <queue>
  36. #include "llrefcount.h"
  37. #include "llpointer.h"
  38. #include "lleventtimer.h"
  39. // Link seam for LLVOVolume
  40. class LLMediaDataClientObject : public LLRefCount
  41. {
  42. public:
  43. // Get the number of media data items
  44. virtual U8 getMediaDataCount() const = 0;
  45. // Get the media data at index, as an LLSD
  46. virtual LLSD getMediaDataLLSD(U8 index) const = 0;
  47. // Get this object's UUID
  48. virtual LLUUID getID() const = 0;
  49. // Navigate back to previous URL
  50. virtual void mediaNavigateBounceBack(U8 index) = 0;
  51. // Does this object have media?
  52. virtual bool hasMedia() const = 0;
  53. // Update the object's media data to the given array
  54. virtual void updateObjectMediaData(LLSD const &media_data_array, const std::string &version_string) = 0;
  55. // Return the total "interest" of the media (on-screen area)
  56. virtual F64 getMediaInterest() const = 0;
  57. // Return the given cap url
  58. virtual std::string getCapabilityUrl(const std::string &name) const = 0;
  59. // Return whether the object has been marked dead
  60. virtual bool isDead() const = 0;
  61. // Returns a media version number for the object
  62. virtual U32 getMediaVersion() const = 0;
  63. // Returns whether the object is "interesting enough" to fetch
  64. virtual bool isInterestingEnough() const = 0;
  65. // Returns whether we've seen this object yet or not
  66. virtual bool isNew() const = 0;
  67. // smart pointer
  68. typedef LLPointer<LLMediaDataClientObject> ptr_t;
  69. };
  70. // This object creates a priority queue for requests.
  71. // Abstracts the Cap URL, the request, and the responder
  72. class LLMediaDataClient : public LLRefCount
  73. {
  74. public:
  75.     LOG_CLASS(LLMediaDataClient);
  76.     
  77.     const static F32 QUEUE_TIMER_DELAY;// = 1.0; // seconds(s)
  78. const static F32 UNAVAILABLE_RETRY_TIMER_DELAY;// = 5.0; // secs
  79. const static U32 MAX_RETRIES;// = 4;
  80. const static U32 MAX_SORTED_QUEUE_SIZE;// = 10000;
  81. const static U32 MAX_ROUND_ROBIN_QUEUE_SIZE;// = 10000;
  82. // Constructor
  83. LLMediaDataClient(F32 queue_timer_delay = QUEUE_TIMER_DELAY,
  84.   F32 retry_timer_delay = UNAVAILABLE_RETRY_TIMER_DELAY,
  85.               U32 max_retries = MAX_RETRIES,
  86.   U32 max_sorted_queue_size = MAX_SORTED_QUEUE_SIZE,
  87.   U32 max_round_robin_queue_size = MAX_ROUND_ROBIN_QUEUE_SIZE);
  88. // Make the request
  89. void request(const LLMediaDataClientObject::ptr_t &object, const LLSD &payload);
  90. F32 getRetryTimerDelay() const { return mRetryTimerDelay; }
  91. // Returns true iff the queue is empty
  92. bool isEmpty() const;
  93. // Returns true iff the given object is in the queue
  94. bool isInQueue(const LLMediaDataClientObject::ptr_t &object);
  95. // Remove the given object from the queue. Returns true iff the given object is removed.
  96. bool removeFromQueue(const LLMediaDataClientObject::ptr_t &object);
  97. // Called only by the Queue timer and tests (potentially)
  98. bool processQueueTimer();
  99. protected:
  100. // Destructor
  101. virtual ~LLMediaDataClient(); // use unref
  102.     
  103. // Request
  104. class Request : public LLRefCount
  105. {
  106. public:
  107.         enum Type {
  108.             GET,
  109.             UPDATE,
  110.             NAVIGATE,
  111. ANY
  112.         };
  113.         
  114. Request(const char *cap_name, const LLSD& sd_payload, LLMediaDataClientObject *obj, LLMediaDataClient *mdc);
  115. const char *getCapName() const { return mCapName; }
  116. const LLSD &getPayload() const { return mPayload; }
  117. LLMediaDataClientObject *getObject() const { return mObject; }
  118.         U32 getNum() const { return mNum; }
  119. U32 getRetryCount() const { return mRetryCount; }
  120. void incRetryCount() { mRetryCount++; }
  121. // Note: may return empty string!
  122. std::string getCapability() const;
  123.         
  124.         Type getType() const;
  125. const char *getTypeAsString() const;
  126. // Re-enqueue thyself
  127. void reEnqueue() const;
  128. F32 getRetryTimerDelay() const;
  129. U32 getMaxNumRetries() const;
  130. bool isNew() const { return mObject.notNull() ? mObject->isNew() : false; }
  131. void markSent(bool flag);
  132. bool isMarkedSent() const { return mMarkedSent; }
  133. void updateScore();
  134. F64 getScore() const { return mScore; }
  135. public:
  136. friend std::ostream& operator<<(std::ostream &s, const Request &q);
  137.     protected:
  138.         virtual ~Request(); // use unref();
  139.         
  140. private:
  141. const char *mCapName;
  142. LLSD mPayload;
  143. LLMediaDataClientObject::ptr_t mObject;
  144. // Simple tracking
  145. U32 mNum;
  146. static U32 sNum;
  147.         U32 mRetryCount;
  148. F64 mScore;
  149. bool mMarkedSent;
  150. // Back pointer to the MDC...not a ref!
  151. LLMediaDataClient *mMDC;
  152. };
  153. typedef LLPointer<Request> request_ptr_t;
  154. // Responder
  155. class Responder : public LLHTTPClient::Responder
  156. {
  157. public:
  158. Responder(const request_ptr_t &request);
  159. //If we get back an error (not found, etc...), handle it here
  160. virtual void error(U32 status, const std::string& reason);
  161. //If we get back a normal response, handle it here.  Default just logs it.
  162. virtual void result(const LLSD& content);
  163. const request_ptr_t &getRequest() const { return mRequest; }
  164.     protected:
  165. virtual ~Responder();
  166.         
  167. private:
  168. class RetryTimer : public LLEventTimer
  169. {
  170. public:
  171. RetryTimer(F32 time, Responder *);
  172. virtual ~RetryTimer();
  173. virtual BOOL tick();
  174. private:
  175. // back-pointer
  176. boost::intrusive_ptr<Responder> mResponder;
  177. };
  178. request_ptr_t mRequest;
  179. };
  180. protected:
  181. // Subclasses must override this factory method to return a new responder
  182. virtual Responder *createResponder(const request_ptr_t &request) const = 0;
  183. // Subclasses must override to return a cap name
  184. virtual const char *getCapabilityName() const = 0;
  185. virtual void sortQueue();
  186. virtual void serviceQueue();
  187. private:
  188. typedef std::list<request_ptr_t> request_queue_t;
  189. void enqueue(const Request*);
  190. // Return whether the given object is/was in the queue
  191. static LLMediaDataClient::request_ptr_t findOrRemove(request_queue_t &queue, const LLMediaDataClientObject::ptr_t &obj, bool remove, Request::Type type);
  192. // Comparator for sorting
  193. static bool compareRequests(const request_ptr_t &o1, const request_ptr_t &o2);
  194. static F64 getObjectScore(const LLMediaDataClientObject::ptr_t &obj);
  195.     
  196. friend std::ostream& operator<<(std::ostream &s, const Request &q);
  197. friend std::ostream& operator<<(std::ostream &s, const request_queue_t &q);
  198. class QueueTimer : public LLEventTimer
  199. {
  200. public:
  201. QueueTimer(F32 time, LLMediaDataClient *mdc);
  202. virtual BOOL tick();
  203.     protected:
  204. virtual ~QueueTimer();
  205. private:
  206. // back-pointer
  207. LLPointer<LLMediaDataClient> mMDC;
  208. };
  209. void startQueueTimer();
  210. void stopQueueTimer();
  211. void setIsRunning(bool val) { mQueueTimerIsRunning = val; }
  212. void swapCurrentQueue();
  213. request_queue_t *getCurrentQueue();
  214. const F32 mQueueTimerDelay;
  215. const F32 mRetryTimerDelay;
  216. const U32 mMaxNumRetries;
  217. const U32 mMaxSortedQueueSize;
  218. const U32 mMaxRoundRobinQueueSize;
  219. bool mQueueTimerIsRunning;
  220. request_queue_t mSortedQueue;
  221. request_queue_t mRoundRobinQueue;
  222. bool mCurrentQueueIsTheSortedQueue;
  223. };
  224. // MediaDataClient specific for the ObjectMedia cap
  225. class LLObjectMediaDataClient : public LLMediaDataClient
  226. {
  227. public:
  228.     LLObjectMediaDataClient(F32 queue_timer_delay = QUEUE_TIMER_DELAY,
  229. F32 retry_timer_delay = UNAVAILABLE_RETRY_TIMER_DELAY,
  230. U32 max_retries = MAX_RETRIES,
  231. U32 max_sorted_queue_size = MAX_SORTED_QUEUE_SIZE,
  232. U32 max_round_robin_queue_size = MAX_ROUND_ROBIN_QUEUE_SIZE)
  233. : LLMediaDataClient(queue_timer_delay, retry_timer_delay, max_retries)
  234. {}
  235.     virtual ~LLObjectMediaDataClient() {}
  236.     
  237. void fetchMedia(LLMediaDataClientObject *object); 
  238.     void updateMedia(LLMediaDataClientObject *object);
  239.     
  240. protected:
  241. // Subclasses must override this factory method to return a new responder
  242. virtual Responder *createResponder(const request_ptr_t &request) const;
  243. // Subclasses must override to return a cap name
  244. virtual const char *getCapabilityName() const;
  245.     
  246.     class Responder : public LLMediaDataClient::Responder
  247.     {
  248.     public:
  249.         Responder(const request_ptr_t &request)
  250.             : LLMediaDataClient::Responder(request) {}
  251.         virtual void result(const LLSD &content);
  252.     };
  253. };
  254. // MediaDataClient specific for the ObjectMediaNavigate cap
  255. class LLObjectMediaNavigateClient : public LLMediaDataClient
  256. {
  257. public:
  258. // NOTE: from llmediaservice.h
  259. static const int ERROR_PERMISSION_DENIED_CODE = 8002;
  260.     LLObjectMediaNavigateClient(F32 queue_timer_delay = QUEUE_TIMER_DELAY,
  261. F32 retry_timer_delay = UNAVAILABLE_RETRY_TIMER_DELAY,
  262. U32 max_retries = MAX_RETRIES,
  263. U32 max_sorted_queue_size = MAX_SORTED_QUEUE_SIZE,
  264. U32 max_round_robin_queue_size = MAX_ROUND_ROBIN_QUEUE_SIZE)
  265. : LLMediaDataClient(queue_timer_delay, retry_timer_delay, max_retries)
  266. {}
  267.     virtual ~LLObjectMediaNavigateClient() {}
  268.     
  269.     void navigate(LLMediaDataClientObject *object, U8 texture_index, const std::string &url);
  270.     
  271. protected:
  272. // Subclasses must override this factory method to return a new responder
  273. virtual Responder *createResponder(const request_ptr_t &request) const;
  274. // Subclasses must override to return a cap name
  275. virtual const char *getCapabilityName() const;
  276.     class Responder : public LLMediaDataClient::Responder
  277.     {
  278.     public:
  279.         Responder(const request_ptr_t &request)
  280.             : LLMediaDataClient::Responder(request) {}
  281. virtual void error(U32 status, const std::string& reason);
  282.         virtual void result(const LLSD &content);
  283.     private:
  284.         void mediaNavigateBounceBack();
  285.     };
  286. };
  287. #endif // LL_LLMEDIADATACLIENT_H