|
1 /* |
|
2 * Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of the License "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * Description: Implementation of CHttpCachePostponeWriteUtilities |
|
15 * |
|
16 */ |
|
17 |
|
18 #ifndef CHTTPCACHEPOSTPONEWRITEUTILS_H |
|
19 #define CHTTPCACHEPOSTPONEWRITEUTILS_H |
|
20 |
|
21 // INCLUDES |
|
22 #include <e32base.h> |
|
23 #include <f32file.h> |
|
24 #include <s32file.h> |
|
25 |
|
26 // CONSTANTS |
|
27 |
|
28 // MACROS |
|
29 #define CACHE_POSTPONE_DEBUG_PRINT |
|
30 // DATA TYPES |
|
31 |
|
32 // FUNCTION PROTOTYPES |
|
33 |
|
34 // FORWARD DECLARATIONS |
|
35 class CHttpCacheEntry; |
|
36 class RFileWriteStream; |
|
37 class RFileReadStream; |
|
38 class CHttpCacheFileWriteHandler; |
|
39 class CHttpCacheHandler; |
|
40 class MHttpCacheWriteSource; |
|
41 |
|
42 /* |
|
43 * CHttpCacheEntryAsyncWriteHelper is responsible for asynchronously writing out the data from a CHttpCacheStreamEntry object. |
|
44 * |
|
45 * It is used in CHttpCacheHandler::FlushAsync() to provide the async write capability. |
|
46 * |
|
47 * At creation, it begins to write the first segment of body data. As each segment completes, the next is written. |
|
48 * Once the body data is written, the headers are written and the status from the header write is returned to the observer. |
|
49 */ |
|
50 NONSHARABLE_CLASS(CHttpCacheEntryAsyncWriteHelper) : public CActive |
|
51 { |
|
52 public: |
|
53 virtual ~CHttpCacheEntryAsyncWriteHelper(); |
|
54 |
|
55 static CHttpCacheEntryAsyncWriteHelper* NewL(MHttpCacheWriteSource* aSource, TRequestStatus& aStatus); |
|
56 TInt GetResult(); // KRequestPending, or a completion code. |
|
57 |
|
58 private: |
|
59 CHttpCacheEntryAsyncWriteHelper(TRequestStatus& aStatus, MHttpCacheWriteSource* aSource, TInt aPriority = EPriorityNormal); |
|
60 |
|
61 virtual void DoCancel(); |
|
62 virtual void RunL(); |
|
63 |
|
64 void ConstructL(); |
|
65 void WriteNextBodyBlock(); |
|
66 |
|
67 private: |
|
68 const TRequestStatus& iSignalStatus; |
|
69 MHttpCacheWriteSource* iSource; |
|
70 TInt iBodyPart; |
|
71 TBool iDone; |
|
72 }; |
|
73 |
|
74 |
|
75 |
|
76 /* |
|
77 * CSegmentedHeapBuffer is a simple segmented buffer. You can add data progressively and storage will |
|
78 * be automatically provided. |
|
79 * |
|
80 * When creating one of these, you provide aBufferSize which is the segment size and aCompressGranularity which is the |
|
81 * multiple which is used to determine if the final block should be shrunk when Compress() is called. |
|
82 */ |
|
83 NONSHARABLE_CLASS(CSegmentedHeapBuffer) : public CBase |
|
84 { |
|
85 public: |
|
86 virtual ~CSegmentedHeapBuffer(); |
|
87 /* |
|
88 * aBufferSize is the size of each segment used for storage. |
|
89 * aCompressGranularity is the multiple used when Compress()ing the last block. |
|
90 */ |
|
91 static CSegmentedHeapBuffer * NewL(TInt aBufferSize = 32768, TInt aCompressGranularity = 4096); |
|
92 |
|
93 /* |
|
94 * @since 5.0 |
|
95 * @param aRemainder [out] - returns the amount of data not consumed from aDes. |
|
96 * @param aDes [in] - the data to append. |
|
97 * @return void |
|
98 * Add some data to the buffer. |
|
99 * |
|
100 * This function will append the data from aDes in chunks of iBufferSize. |
|
101 * aRemainder will normally be zero after completion of this call, however if AppendL |
|
102 * does leave, then aRemainder will tell you how many bytes from aDes have not been consumed. |
|
103 * This is intended for calling code to cope in the case where the buffer cannot be extended (KErrNoMemory) |
|
104 * to contain the whole descriptor. Calling code can take remedial action and know exactly how much data |
|
105 * is left to handle. |
|
106 */ |
|
107 void AppendL(TInt& aRemainder, const TDesC8& aDes); |
|
108 |
|
109 /* |
|
110 * @since 5.0 |
|
111 * @param aSegment [in & out] - in -> the segment to address, out -> next segment. |
|
112 * @return Segment data descriptor. |
|
113 * |
|
114 * Access data in the buffer. |
|
115 * |
|
116 * Simply returns descriptor giving access to the desired segment. |
|
117 * Normal usage is to call with aSegment initialised to zero. |
|
118 * Repeated calls with same aSegment will result in iterator behaviour. |
|
119 * Do not call past number of available segments as returned by Count() - this will result in a panic from |
|
120 * addressing past the end of the RPointerArray. |
|
121 */ |
|
122 TPtrC8 GetSegmentData(TInt& aSegment); |
|
123 |
|
124 /* |
|
125 * @since 5.0 |
|
126 * @param aSegment [in] - the segment to free. |
|
127 * @return void |
|
128 * |
|
129 * Release data in the buffer. |
|
130 * |
|
131 * Frees the requested segment without changing segment numbering and order. |
|
132 */ |
|
133 void ReleaseSegmentData(const TInt aSegment); |
|
134 |
|
135 TInt Length(); // amount of data stored |
|
136 TInt SpareCapacity(); // spare space in last block |
|
137 TInt Count(); // number of blocks |
|
138 |
|
139 void Compress(); // release space at end of last block. |
|
140 void Reset(); // release all allocated storage |
|
141 private: |
|
142 void ConstructL(); |
|
143 CSegmentedHeapBuffer(TInt aBufferSize, TInt aCompressGranularity); |
|
144 |
|
145 private: |
|
146 const TInt iBufferSize; |
|
147 const TInt iCompressGranularity; |
|
148 RPointerArray<HBufC8> iBufferList; |
|
149 }; |
|
150 // CLASS DECLARATION |
|
151 |
|
152 |
|
153 NONSHARABLE_CLASS(MHttpCacheWriteSource) |
|
154 { |
|
155 public: |
|
156 virtual RFile& BodyFile() = 0; |
|
157 virtual void BodyWriteInProgress() = 0; |
|
158 virtual void BodyWriteComplete() = 0; |
|
159 virtual CSegmentedHeapBuffer& BodyData() = 0; |
|
160 }; |
|
161 |
|
162 // calls the given function when the preset timer expires. |
|
163 NONSHARABLE_CLASS(CHttpCacheWriteTimeout) : public CActive |
|
164 { |
|
165 public: |
|
166 // Cancel and destroy |
|
167 ~CHttpCacheWriteTimeout (); |
|
168 |
|
169 // Two-phased constructor. |
|
170 static CHttpCacheWriteTimeout* NewL (const TInt aTimeout); |
|
171 |
|
172 // Two-phased constructor. |
|
173 static CHttpCacheWriteTimeout* NewLC (const TInt aTimeout); |
|
174 |
|
175 public: |
|
176 // New functions |
|
177 // Function for making the initial request |
|
178 void Start(TCallBack aCallbackFn, TAny *aToken); |
|
179 |
|
180 private: |
|
181 // C++ constructor |
|
182 CHttpCacheWriteTimeout (const TInt aTimeout); |
|
183 |
|
184 // Second-phase constructor |
|
185 void ConstructL (); |
|
186 |
|
187 private: |
|
188 // From CActive |
|
189 // Handle completion |
|
190 void RunL (); |
|
191 |
|
192 // How to cancel me |
|
193 void DoCancel (); |
|
194 |
|
195 // Override to handle leaves from RunL(). Default implementation causes |
|
196 // the active scheduler to panic. |
|
197 TInt RunError (TInt aError); |
|
198 |
|
199 private: |
|
200 TInt iTimeout; |
|
201 RTimer iTimer; // Provides async timing service |
|
202 TCallBack iCallbackFn; |
|
203 TAny *iToken; |
|
204 }; |
|
205 |
|
206 |
|
207 |
|
208 #endif // CHTTPCACHEPOSTPONEWRITEUTILS_H |
|
209 |
|
210 // End of File |