|
1 // Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies). |
|
2 // All rights reserved. |
|
3 // This component and the accompanying materials are made available |
|
4 // under the terms of "Eclipse Public License v1.0" |
|
5 // which accompanies this distribution, and is available |
|
6 // at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
7 // |
|
8 // Initial Contributors: |
|
9 // Nokia Corporation - initial contribution. |
|
10 // |
|
11 // Contributors: |
|
12 // |
|
13 // Description: |
|
14 // |
|
15 |
|
16 #include <mmf/common/mmfcontrollerframework.h> |
|
17 #include "MmfDrmPluginServerSession.h" |
|
18 #include "MmfDrmPluginClientServer.h" |
|
19 #include "MmfDrmPluginServer.h" |
|
20 |
|
21 /* |
|
22 Create a DRM Plugin Server Session |
|
23 */ |
|
24 CMMFDRMPluginServerSession* CMMFDRMPluginServerSession::NewL() |
|
25 { |
|
26 CMMFDRMPluginServerSession* self = new(ELeave) CMMFDRMPluginServerSession(); |
|
27 return self; |
|
28 } |
|
29 |
|
30 CMMFDRMPluginServerSession::~CMMFDRMPluginServerSession() |
|
31 { |
|
32 CMMFDRMPluginServer* server = |
|
33 const_cast<CMMFDRMPluginServer*>(static_cast<const CMMFDRMPluginServer*>(Server())); |
|
34 if (server) |
|
35 { |
|
36 server->DecrementSessionId(); |
|
37 } |
|
38 if (iData) |
|
39 { |
|
40 delete iData; |
|
41 } |
|
42 iControllerSessionHandle.Close(); |
|
43 } |
|
44 |
|
45 void CMMFDRMPluginServerSession::CreateL(const CMmfIpcServer& aServer) |
|
46 { |
|
47 CMmfIpcSession::CreateL(aServer); |
|
48 CMMFDRMPluginServer* server = |
|
49 static_cast<CMMFDRMPluginServer*>(CONST_CAST(CMmfIpcServer*, &aServer)); |
|
50 server->IncrementSessionId(); |
|
51 } |
|
52 |
|
53 void CMMFDRMPluginServerSession::ServiceL(const RMmfIpcMessage& aMessage) |
|
54 { |
|
55 switch (aMessage.Function()) |
|
56 { |
|
57 case EMMFControllerLaunchRequest: |
|
58 DoLaunchControllerL(aMessage); |
|
59 aMessage.Complete(KErrNone); |
|
60 break; |
|
61 case EMMFControllerSessionHandle: |
|
62 if (!iControllerSessionHandle.Handle()) |
|
63 { |
|
64 User::Leave(KErrNotReady); |
|
65 } |
|
66 aMessage.Complete(iControllerSessionHandle); |
|
67 break; |
|
68 case EMMFControllerThreadPanic: |
|
69 DoPanicControllerThreadL(aMessage); |
|
70 aMessage.Complete(KErrNone); |
|
71 break; |
|
72 case EMMFControllerThreadKill: |
|
73 DoKillControllerThreadL(aMessage); |
|
74 aMessage.Complete(KErrNone); |
|
75 break; |
|
76 case EMMFControllerSetThreadPriority: |
|
77 DoSetThreadPriorityL(aMessage); |
|
78 aMessage.Complete(KErrNone); |
|
79 break; |
|
80 case EMMFDRMContentOpenByFilePath: |
|
81 DoOpenContentByFilePathL(aMessage); |
|
82 aMessage.Complete(KErrNone); |
|
83 break; |
|
84 case EMMFDRMContentOpenByFileHandle: |
|
85 DoOpenContentByFileHandleL(aMessage); |
|
86 aMessage.Complete(KErrNone); |
|
87 break; |
|
88 case EMMFDRMContentEvaluateIntent: |
|
89 { |
|
90 TInt err = DoEvaluateContentIntent(aMessage); |
|
91 aMessage.Complete(err); |
|
92 } |
|
93 break; |
|
94 case EMMFDRMContentGetMimeType: |
|
95 DoGetContentMimeTypeL(aMessage); |
|
96 aMessage.Complete(KErrNone); |
|
97 break; |
|
98 case EMMFDRMContentGetFileHeader: |
|
99 DoGetContentFileHeaderL(aMessage); |
|
100 aMessage.Complete(KErrNone); |
|
101 break; |
|
102 case EMMFSetDrmPluginServerTimeout: |
|
103 DoSetDrmPluginServerTimeout(aMessage); |
|
104 aMessage.Complete(KErrNone); |
|
105 break; |
|
106 default: |
|
107 User::Leave(KErrNotSupported); |
|
108 break; |
|
109 } |
|
110 } |
|
111 |
|
112 CMMFDRMPluginServerSession::CMMFDRMPluginServerSession() |
|
113 { |
|
114 } |
|
115 |
|
116 void CMMFDRMPluginServerSession::DoLaunchControllerL(const RMmfIpcMessage& aMessage) |
|
117 { |
|
118 if (iControllerSessionHandle.Handle()) |
|
119 { |
|
120 User::Leave(KErrAlreadyExists); |
|
121 } |
|
122 TThreadId controllerTID; |
|
123 RMMFControllerServerProxy controllerSessionHandle; |
|
124 CMMFDRMPluginServer* server = |
|
125 const_cast<CMMFDRMPluginServer*>(static_cast<const CMMFDRMPluginServer*>(Server())); |
|
126 |
|
127 RThread clientThread; |
|
128 CleanupClosePushL(clientThread); |
|
129 User::LeaveIfError(aMessage.Client(clientThread)); |
|
130 |
|
131 TPckg<TUint> maxHeapSize(0); |
|
132 TPckg<TBool> useShareHeap(ETrue); |
|
133 TPckg<TBool> stackSize(0); |
|
134 |
|
135 aMessage.ReadL(0, maxHeapSize); |
|
136 aMessage.ReadL(1, useShareHeap); |
|
137 aMessage.ReadL(3, stackSize); |
|
138 |
|
139 User::LeaveIfError(server->StartControllerServer(clientThread, maxHeapSize(), useShareHeap(), |
|
140 controllerSessionHandle, controllerTID, stackSize())); |
|
141 SetControllerServerInfo(controllerSessionHandle, controllerTID); |
|
142 |
|
143 TPckgBuf<TThreadId> threadId(iControllerThreadID); |
|
144 aMessage.WriteL(2, threadId); |
|
145 CleanupStack::PopAndDestroy(&clientThread); |
|
146 } |
|
147 |
|
148 void CMMFDRMPluginServerSession::DoPanicControllerThreadL(const RMmfIpcMessage& aMessage) |
|
149 { |
|
150 TPckgBuf<TThreadId> controllerTid(0); |
|
151 aMessage.ReadL(0, controllerTid); |
|
152 |
|
153 TInt desLen = aMessage.GetDesLengthL(1); |
|
154 HBufC* category = HBufC::NewLC(desLen); |
|
155 TPtr categoryPtr(category->Des()); |
|
156 aMessage.ReadL(1, categoryPtr); |
|
157 |
|
158 TPckg<TInt> panicReason(0); |
|
159 aMessage.ReadL(2, panicReason); |
|
160 |
|
161 CMMFDRMPluginServer* server = |
|
162 const_cast<CMMFDRMPluginServer*>(static_cast<const CMMFDRMPluginServer*>(Server())); |
|
163 server->PanicControllerThread(controllerTid(), categoryPtr, panicReason()); |
|
164 |
|
165 CleanupStack::PopAndDestroy(category); |
|
166 } |
|
167 |
|
168 void CMMFDRMPluginServerSession::DoKillControllerThreadL(const RMmfIpcMessage& aMessage) |
|
169 { |
|
170 TPckgBuf<TThreadId> controllerTid(0); |
|
171 aMessage.ReadL(0, controllerTid); |
|
172 |
|
173 TPckg<TInt> killReason(0); |
|
174 aMessage.ReadL(1, killReason); |
|
175 |
|
176 CMMFDRMPluginServer* server = |
|
177 const_cast<CMMFDRMPluginServer*>(static_cast<const CMMFDRMPluginServer*>(Server())); |
|
178 server->KillControllerThread(controllerTid(), killReason()); |
|
179 } |
|
180 |
|
181 void CMMFDRMPluginServerSession::SetControllerServerInfo(RHandleBase& aControllerSessionHandle, |
|
182 TThreadId& aControllerThreadId) |
|
183 { |
|
184 iControllerSessionHandle = aControllerSessionHandle; |
|
185 iControllerThreadID = aControllerThreadId; |
|
186 } |
|
187 |
|
188 void CMMFDRMPluginServerSession::DoSetThreadPriorityL(const RMmfIpcMessage& aMessage) |
|
189 { |
|
190 TPckgBuf<TThreadId> threadId; |
|
191 TPckgBuf<TThreadPriority> priority; |
|
192 |
|
193 aMessage.ReadL(0, threadId); |
|
194 aMessage.ReadL(1, priority); |
|
195 |
|
196 CMMFDRMPluginServer* server = |
|
197 const_cast<CMMFDRMPluginServer*>(static_cast<const CMMFDRMPluginServer*>(Server())); |
|
198 User::LeaveIfError(server->SetThreadPriority(threadId(), priority())); |
|
199 } |
|
200 |
|
201 void CMMFDRMPluginServerSession::DoOpenContentByFilePathL(const RMmfIpcMessage& aMessage) |
|
202 { |
|
203 if (iData == NULL) |
|
204 { |
|
205 TInt length = aMessage.GetDesLengthL(0); |
|
206 HBufC* filePath = HBufC::NewLC(length); |
|
207 TPtr filePathPtr(filePath->Des()); |
|
208 aMessage.ReadL(0, filePathPtr); |
|
209 |
|
210 length = aMessage.GetDesLengthL(1); |
|
211 HBufC8* initData = HBufC8::NewLC(length); |
|
212 TPtr8 initDataPtr(initData->Des()); |
|
213 aMessage.ReadL(1, initDataPtr); |
|
214 |
|
215 HBufC* uniqueId = NULL; |
|
216 TBool UIEnabled; |
|
217 ContentAccess::TIntent intent; |
|
218 GetContentInitDataL(initDataPtr, uniqueId, UIEnabled, intent); |
|
219 CleanupStack::PopAndDestroy(initData); |
|
220 CleanupStack::PushL(uniqueId); |
|
221 |
|
222 iData = CData::NewL(TVirtualPathPtr(filePathPtr, *uniqueId), EContentShareReadWrite); |
|
223 TInt err = iData->SetProperty(EAgentPropertyAgentUI, UIEnabled); |
|
224 if (err != KErrNone && err != KErrCANotSupported) |
|
225 { |
|
226 // KErrCANotSupported isn't a problem for us so eat the error code. |
|
227 User::Leave(err); |
|
228 } |
|
229 User::LeaveIfError(iData->EvaluateIntent(intent)); |
|
230 |
|
231 CleanupStack::PopAndDestroy(2, filePath); // uniqueId, filePath |
|
232 } |
|
233 else |
|
234 { |
|
235 User::Leave(KErrAlreadyExists); |
|
236 } |
|
237 } |
|
238 |
|
239 void CMMFDRMPluginServerSession::DoOpenContentByFileHandleL(const RMmfIpcMessage& aMessage) |
|
240 { |
|
241 if (iData == NULL) |
|
242 { |
|
243 RFile file; |
|
244 User::LeaveIfError(file.AdoptFromClient(aMessage, 0, 1)); |
|
245 CleanupClosePushL(file); |
|
246 |
|
247 TInt length = aMessage.GetDesLengthL(2); |
|
248 HBufC8* initData = HBufC8::NewLC(length); |
|
249 TPtr8 initDataPtr(initData->Des()); |
|
250 aMessage.ReadL(2, initDataPtr); |
|
251 |
|
252 HBufC* uniqueId = NULL; |
|
253 TBool UIEnabled; |
|
254 ContentAccess::TIntent intent; |
|
255 GetContentInitDataL(initDataPtr, uniqueId, UIEnabled, intent); |
|
256 CleanupStack::PopAndDestroy(initData); |
|
257 CleanupStack::PushL(uniqueId); |
|
258 |
|
259 iData = CData::NewL(file, *uniqueId); |
|
260 TInt err = iData->SetProperty(EAgentPropertyAgentUI, UIEnabled); |
|
261 if (err != KErrNone && err != KErrCANotSupported) |
|
262 { |
|
263 // KErrCANotSupported isn't a problem for us so eat the error code. |
|
264 User::Leave(err); |
|
265 } |
|
266 User::LeaveIfError(iData->EvaluateIntent(intent)); |
|
267 |
|
268 CleanupStack::PopAndDestroy(2, &file); // uniqueId, file |
|
269 } |
|
270 else |
|
271 { |
|
272 User::Leave(KErrAlreadyExists); |
|
273 } |
|
274 } |
|
275 |
|
276 void CMMFDRMPluginServerSession::GetContentInitDataL(const TDesC8& aInitData, HBufC*& aUniqueId, |
|
277 TBool& aUIEnabled, ContentAccess::TIntent& aIntent) |
|
278 { |
|
279 if (aUniqueId) |
|
280 { |
|
281 delete aUniqueId; |
|
282 aUniqueId = NULL; |
|
283 } |
|
284 |
|
285 RDesReadStream stream(aInitData); |
|
286 CleanupClosePushL(stream); |
|
287 |
|
288 TInt length = stream.ReadInt32L(); |
|
289 aUniqueId = HBufC::NewLC(length); |
|
290 TPtr ptr = aUniqueId->Des(); |
|
291 stream.ReadL(ptr, length); |
|
292 |
|
293 aUIEnabled = stream.ReadInt32L(); |
|
294 TPckgBuf<ContentAccess::TIntent> intentPckg; |
|
295 stream.ReadL(intentPckg); |
|
296 aIntent = intentPckg(); |
|
297 |
|
298 CleanupStack::Pop(aUniqueId); |
|
299 CleanupStack::PopAndDestroy(&stream); |
|
300 } |
|
301 |
|
302 TInt CMMFDRMPluginServerSession::DoEvaluateContentIntent(const RMmfIpcMessage& aMessage) |
|
303 { |
|
304 TInt err; |
|
305 if (iData) |
|
306 { |
|
307 TPckgBuf<TIntent> intentPckg; |
|
308 err = aMessage.Read(0, intentPckg); |
|
309 if (err == KErrNone) |
|
310 { |
|
311 err = iData->EvaluateIntent(intentPckg()); |
|
312 } |
|
313 } |
|
314 else |
|
315 { |
|
316 err = KErrGeneral; |
|
317 } |
|
318 return err; |
|
319 } |
|
320 |
|
321 void CMMFDRMPluginServerSession::DoGetContentMimeTypeL(const RMmfIpcMessage& aMessage) |
|
322 { |
|
323 if (iData) |
|
324 { |
|
325 TBool success = ETrue; |
|
326 TInt length = aMessage.GetDesMaxLengthL(0); |
|
327 |
|
328 HBufC* mimeType = HBufC::NewLC(length); |
|
329 TPtr mimeTypePtr = mimeType->Des(); |
|
330 TInt err = iData->GetStringAttribute(EMimeType, mimeTypePtr); |
|
331 |
|
332 if (err == KErrNone) |
|
333 { |
|
334 HBufC8* mimeType8 = HBufC8::NewLC(length); |
|
335 TPtr8 mimeTypePtr8 = mimeType8->Des(); |
|
336 mimeTypePtr8.Copy(mimeTypePtr); |
|
337 |
|
338 aMessage.WriteL(0, mimeTypePtr8); |
|
339 CleanupStack::PopAndDestroy(mimeType8); |
|
340 } |
|
341 else |
|
342 { |
|
343 success = EFalse; |
|
344 } |
|
345 CleanupStack::PopAndDestroy(mimeType); |
|
346 |
|
347 TPckg<TBool> successPckg(success); |
|
348 aMessage.WriteL(1, successPckg); |
|
349 } |
|
350 else |
|
351 { |
|
352 User::Leave(KErrGeneral); |
|
353 } |
|
354 } |
|
355 |
|
356 void CMMFDRMPluginServerSession::DoGetContentFileHeaderL(const RMmfIpcMessage& aMessage) |
|
357 { |
|
358 if (iData) |
|
359 { |
|
360 TInt size = 0; |
|
361 iData->DataSizeL(size); |
|
362 |
|
363 TInt maxLength = aMessage.Int0(); |
|
364 |
|
365 TInt desLength = aMessage.GetDesMaxLengthL(1); |
|
366 HBufC8* header = HBufC8::NewLC(desLength); |
|
367 TPtr8 headerPtr = header->Des(); |
|
368 |
|
369 if (size > 0) |
|
370 { |
|
371 if (size > maxLength) |
|
372 { |
|
373 size = maxLength; |
|
374 } |
|
375 TInt pos = 0; |
|
376 User::LeaveIfError(iData->Seek(ESeekStart, pos)); |
|
377 User::LeaveIfError(iData->Read(headerPtr, size)); |
|
378 aMessage.WriteL(1, headerPtr); |
|
379 } |
|
380 CleanupStack::PopAndDestroy(header); |
|
381 } |
|
382 else |
|
383 { |
|
384 User::Leave(KErrGeneral); |
|
385 } |
|
386 } |
|
387 |
|
388 void CMMFDRMPluginServerSession::DoSetDrmPluginServerTimeout(const RMmfIpcMessage& aMessage) |
|
389 { |
|
390 CMMFDRMPluginServer* server = |
|
391 const_cast<CMMFDRMPluginServer*>(static_cast<const CMMFDRMPluginServer*>(Server())); |
|
392 server->SetTimeout(aMessage.Int0()); |
|
393 } |
|
394 |