|
1 /**************************************************************************** |
|
2 ** |
|
3 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies). |
|
4 ** All rights reserved. |
|
5 ** Contact: Nokia Corporation (qt-info@nokia.com) |
|
6 ** |
|
7 ** This file is part of the Qt Mobility Components. |
|
8 ** |
|
9 ** $QT_BEGIN_LICENSE:LGPL$ |
|
10 ** No Commercial Usage |
|
11 ** This file contains pre-release code and may not be distributed. |
|
12 ** You may use this file in accordance with the terms and conditions |
|
13 ** contained in the Technology Preview License Agreement accompanying |
|
14 ** this package. |
|
15 ** |
|
16 ** GNU Lesser General Public License Usage |
|
17 ** Alternatively, this file may be used under the terms of the GNU Lesser |
|
18 ** General Public License version 2.1 as published by the Free Software |
|
19 ** Foundation and appearing in the file LICENSE.LGPL included in the |
|
20 ** packaging of this file. Please review the following information to |
|
21 ** ensure the GNU Lesser General Public License version 2.1 requirements |
|
22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. |
|
23 ** |
|
24 ** In addition, as a special exception, Nokia gives you certain additional |
|
25 ** rights. These rights are described in the Nokia Qt LGPL Exception |
|
26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. |
|
27 ** |
|
28 ** If you have questions regarding the use of this file, please contact |
|
29 ** Nokia at qt-info@nokia.com. |
|
30 ** |
|
31 ** |
|
32 ** |
|
33 ** |
|
34 ** |
|
35 ** |
|
36 ** |
|
37 ** |
|
38 ** $QT_END_LICENSE$ |
|
39 ** |
|
40 ****************************************************************************/ |
|
41 |
|
42 #include "eventloggerengine_maemo_p.h" |
|
43 #include "telepathyengine_maemo_p.h" |
|
44 #include <QDebug> |
|
45 |
|
46 QTM_BEGIN_NAMESPACE |
|
47 |
|
48 |
|
49 Q_GLOBAL_STATIC(EventLoggerEngine,eventLoggerEngine); |
|
50 |
|
51 |
|
52 EventLoggerEngine* EventLoggerEngine::instance() |
|
53 { |
|
54 return eventLoggerEngine(); |
|
55 } |
|
56 |
|
57 |
|
58 EventLoggerEngine::EventLoggerEngine(QObject *parent):QObject(parent) |
|
59 { |
|
60 // qDebug() << "EventLoggerEngine::EventLoggerEngine"; |
|
61 DBusError err=DBUS_ERROR_INIT; |
|
62 active = false; |
|
63 g_type_init(); |
|
64 dbus = dbus_bus_get(DBUS_BUS_SESSION, &err); // Create dummy Dbus object and |
|
65 dbus_connection_setup_with_g_main (dbus, NULL); //add it to g_mainloop because eventlogger library expects that someone alse has added session bus to g_mainloop |
|
66 el=rtcom_el_new (); |
|
67 if(!RTCOM_IS_EL(el)) qDebug() << "EventLoggerEngine::EventLoggerEngine():Could't create RTComEl\n"; |
|
68 |
|
69 queryThread=0; |
|
70 // queryThread.run(); |
|
71 // connect(queryThread, SIGNAL(messagesFound(const QMessageIdList &)),this, SLOT(messagesFound_(const QMessageIdList &))); |
|
72 |
|
73 |
|
74 g_signal_connect(G_OBJECT(el), "new-event", G_CALLBACK(new_event_cb),(void*)this); |
|
75 } |
|
76 |
|
77 void EventLoggerEngine::new_event_cb(RTComEl *el,int event_id, |
|
78 const char *local_uid,const char *remote_uid,const char *remote_ebook_uid, |
|
79 const char *group_uid,const char *service,EventLoggerEngine *p) |
|
80 { |
|
81 Q_UNUSED(el); |
|
82 p->newEvent(event_id, local_uid,remote_uid ,remote_ebook_uid,group_uid,service); |
|
83 }; |
|
84 |
|
85 void EventLoggerEngine::newEvent(int event_id, |
|
86 const char *local_uid,const char *remote_uid,const char *remote_ebook_uid, |
|
87 const char *group_uid,const char *service) |
|
88 { |
|
89 Q_UNUSED(local_uid); Q_UNUSED(remote_uid);Q_UNUSED(remote_ebook_uid); |
|
90 Q_UNUSED(group_uid);Q_UNUSED(service); |
|
91 QString eventIds=QString("el")+QString::number(event_id); |
|
92 QMessageId id(eventIds); |
|
93 |
|
94 |
|
95 notification(event_id,service,QMessageStorePrivate::Added); |
|
96 } |
|
97 |
|
98 QMessageManager::NotificationFilterId EventLoggerEngine::registerNotificationFilter(QMessageStorePrivate& aPrivateStore, |
|
99 const QMessageFilter &filter) |
|
100 { |
|
101 iListenForNotifications = true; |
|
102 ipMessageStorePrivate = &aPrivateStore; |
|
103 |
|
104 int filterId = ++_filterId; |
|
105 _filters.insert(filterId, filter); |
|
106 return filterId; |
|
107 } |
|
108 |
|
109 void EventLoggerEngine::unregisterNotificationFilter(QMessageManager::NotificationFilterId notificationFilterId) |
|
110 { |
|
111 _filters.remove(notificationFilterId); |
|
112 if (_filters.count() == 0) { |
|
113 iListenForNotifications = false; |
|
114 } |
|
115 } |
|
116 QMessage EventLoggerEngine::eventToMessage(RTComElEvent & ev) |
|
117 { |
|
118 |
|
119 QMessage message; |
|
120 |
|
121 if (!strcmp(ev.fld_service, "RTCOM_EL_SERVICE_SMS")) { |
|
122 message.setType(QMessage::Sms); |
|
123 } else if (!strcmp(ev.fld_service,"RTCOM_EL_SERVICE_CHAT")) { |
|
124 message.setType(QMessage::InstantMessage); |
|
125 } else { |
|
126 message.setType(QMessage::NoType); // Other type, as exampele voice Call |
|
127 }; |
|
128 |
|
129 message.setParentAccountId(QMessageAccountId(QString("y/Account/%1").arg(ev.fld_local_uid))); |
|
130 |
|
131 if (!ev.fld_is_read) { |
|
132 message.setStatus(QMessage::Read); |
|
133 }; |
|
134 message.setPriority(QMessage::NormalPriority); |
|
135 message.setDate(QDateTime::fromTime_t(ev.fld_start_time)); |
|
136 message.setReceivedDate(QDateTime::fromTime_t(ev.fld_start_time)); |
|
137 if (ev.fld_outgoing) QMessagePrivate::setStandardFolder(message,QMessage::SentFolder); |
|
138 else |
|
139 QMessagePrivate::setStandardFolder(message,QMessage::InboxFolder); |
|
140 // qDebug() << "event_type:" << ev.fld_event_type << ev.fld_event_type_id << "Outgoing:" << ev.fld_outgoing << " Folder:" << message.standardFolder(); |
|
141 message.setFrom(QMessageAddress(QMessageAddress::Phone, QString(ev.fld_remote_uid))); |
|
142 QMessagePrivate::setSenderName(message, QString(ev.fld_remote_uid)); |
|
143 QMessageAddressList messageAddresslist; |
|
144 messageAddresslist.append(QMessageAddress(QMessageAddress::Phone, QString(ev.fld_local_uid))); |
|
145 message.setTo(messageAddresslist); |
|
146 message.setBody(QString(ev.fld_free_text)); |
|
147 QMessagePrivate* privateMessage = QMessagePrivate::implementation(message); |
|
148 privateMessage->_id = QMessageId(QString("el")+QString::number(ev.fld_id)); |
|
149 privateMessage->_modified = false; |
|
150 // qDebug() << "id:" << message.id().toString() << "From:" << message.from().addressee() << "Text:" << message.textContent(); |
|
151 return message; |
|
152 |
|
153 } |
|
154 void EventLoggerEngine::addEvent(QMessage &message) |
|
155 { |
|
156 qDebug() << "EventLoggerEngine::addEvent()\n"; |
|
157 RTComElEvent *ev = rtcom_el_event_new(); |
|
158 |
|
159 if (message.type()==QMessage::Sms) { |
|
160 RTCOM_EL_EVENT_SET_FIELD(ev,service,(gchar *)"RTCOM_EL_SERVICE_SMS"); |
|
161 } |
|
162 else if (message.type()==QMessage::InstantMessage) { |
|
163 RTCOM_EL_EVENT_SET_FIELD(ev,service,(gchar *)"RTCOM_EL_SERVICE_CHAT"); |
|
164 RTCOM_EL_EVENT_SET_FIELD(ev,remote_uid,(gchar *)message.from().addressee().toStdString().c_str()); |
|
165 RTCOM_EL_EVENT_SET_FIELD(ev,group_uid,(gchar *)message.from().addressee().toStdString().c_str()); |
|
166 } |
|
167 else return; // Invalid messge type |
|
168 |
|
169 RTCOM_EL_EVENT_SET_FIELD(ev,event_type,(gchar *)"RTCOM_EL_EVENTTYPE_SMS_INBOUND"); |
|
170 RTCOM_EL_EVENT_SET_FIELD(ev,local_uid,(gchar *)"ring/tel/ring"); |
|
171 RTCOM_EL_EVENT_SET_FIELD(ev,local_name,(gchar *)"<SelfHandle>"); |
|
172 RTCOM_EL_EVENT_SET_FIELD(ev,remote_uid,(gchar *)message.from().addressee().toStdString().c_str()); |
|
173 RTCOM_EL_EVENT_SET_FIELD(ev,group_uid,(gchar *)message.from().addressee().toStdString().c_str()); |
|
174 RTCOM_EL_EVENT_SET_FIELD(ev,start_time,time(NULL)); |
|
175 RTCOM_EL_EVENT_SET_FIELD(ev,remote_ebook_uid,(gchar *)"1"); |
|
176 RTCOM_EL_EVENT_SET_FIELD(ev,free_text,(gchar *)message.textContent().toStdString().c_str()); |
|
177 rtcom_el_add_event(el,ev,NULL); |
|
178 rtcom_el_event_free(ev); |
|
179 } |
|
180 |
|
181 bool EventLoggerEngine::deleteMessage(const QMessageId& id) |
|
182 { |
|
183 int status=rtcom_el_delete_event(el,id.toString().remove("el").toInt(),NULL); |
|
184 return status==0; |
|
185 } |
|
186 |
|
187 QMessage EventLoggerEngine::message(const QMessageId& id) |
|
188 { |
|
189 |
|
190 QMessage message; |
|
191 |
|
192 // qDebug() << "EventLoggerEngine::getMessage id=" << id.toString(); |
|
193 |
|
194 RTComElEvent ev; |
|
195 bzero(&ev,sizeof(ev)); |
|
196 RTComElQuery *q=rtcom_el_query_new(el); |
|
197 rtcom_el_query_prepare(q,"id",id.toString().remove("el").toInt(),RTCOM_EL_OP_EQUAL,NULL); |
|
198 RTComElIter *iter=rtcom_el_get_events(el,q); |
|
199 g_object_unref(q); |
|
200 if(iter && rtcom_el_iter_first(iter)) |
|
201 { |
|
202 gboolean res=rtcom_el_iter_get_full(iter,&ev); |
|
203 if(res) { |
|
204 #if 0 |
|
205 printf("got event id=%d service_id=%d event_typ_id=%d\n\ |
|
206 local_uid=%s local_name=%s\n\ |
|
207 remote_uid=%s remote_name=%s remote_ebook_uid=%s\n\ |
|
208 channel=%s free_text=%s group_uid=%s\n\ |
|
209 service=%s event_type=%s\n\ |
|
210 additional_text=%s icon_name=%s pango_markup=%s\n", |
|
211 ev.fld_id,ev.fld_service_id,ev.fld_event_type_id, |
|
212 ev.fld_local_uid,ev.fld_local_name, |
|
213 ev.fld_remote_uid,ev.fld_remote_name,ev.fld_remote_ebook_uid, |
|
214 ev.fld_channel,ev.fld_free_text,ev.fld_group_uid, |
|
215 ev.fld_service,ev.fld_event_type, |
|
216 ev.fld_additional_text,ev.fld_icon_name,ev.fld_pango_markup); |
|
217 #endif |
|
218 if (!strcmp(ev.fld_service, "RTCOM_EL_SERVICE_SMS")) { |
|
219 message.setType(QMessage::Sms); |
|
220 } else if (!strcmp(ev.fld_service,"RTCOM_EL_SERVICE_CHAT")) { |
|
221 message.setType(QMessage::InstantMessage); |
|
222 } else { |
|
223 message.setType(QMessage::NoType); // Other type, as exampele voice Call |
|
224 }; |
|
225 //QMessageAccount account = TelepathyEngine::instance()->account(QMessageAccountId(QString("/y/Account%1").arg(ev.fld_local_uid))); |
|
226 |
|
227 message.setParentAccountId(QMessageAccountId(QString("/y/Account/%1").arg(ev.fld_local_uid))); |
|
228 if (!ev.fld_is_read) { |
|
229 message.setStatus(QMessage::Read); |
|
230 }; |
|
231 message.setPriority(QMessage::NormalPriority); |
|
232 message.setDate(QDateTime::fromTime_t(ev.fld_start_time)); |
|
233 message.setReceivedDate(QDateTime::fromTime_t(ev.fld_start_time)); |
|
234 if (ev.fld_outgoing) QMessagePrivate::setStandardFolder(message,QMessage::SentFolder); |
|
235 else |
|
236 QMessagePrivate::setStandardFolder(message,QMessage::InboxFolder); |
|
237 message.setFrom(QMessageAddress(QMessageAddress::Phone, QString(ev.fld_remote_uid))); |
|
238 QMessagePrivate::setSenderName(message, QString(ev.fld_remote_uid)); |
|
239 QMessageAddressList messageAddresslist; |
|
240 messageAddresslist.append(QMessageAddress(QMessageAddress::Phone, QString(ev.fld_local_uid))); |
|
241 message.setTo(messageAddresslist); |
|
242 message.setBody(QString(ev.fld_free_text)); |
|
243 QMessagePrivate* privateMessage = QMessagePrivate::implementation(message); |
|
244 privateMessage->_id = id; |
|
245 privateMessage->_modified = false; |
|
246 // qDebug() << "id:" << message.id().toString() << "From:" << message.from().addressee() << "Text:" << message.textContent(); |
|
247 }; |
|
248 }; |
|
249 if(iter) g_object_unref(iter); |
|
250 // debugMessage(message); |
|
251 |
|
252 return message; |
|
253 |
|
254 } |
|
255 |
|
256 void EventLoggerEngine::debugMessage(QMessage &message) |
|
257 { |
|
258 qDebug() << "id:" << message.id().toString() << "type:" << message.type() << "size:" << message.size() << "status:" << message.status() << "priority:" << message.priority(); |
|
259 qDebug() << "AccountId:" << message.parentAccountId().toString() << "StantardFolder" << message.standardFolder() << "parenFolderId:" << message.parentFolderId().toString(); |
|
260 qDebug() << "Date:" << message.date() << "receivedDate:" << message.receivedDate() << "Subject:" << message.subject(); |
|
261 qDebug() << "From:" << message.from().addressee(); |
|
262 qDebug() << "To:" << (message.to().isEmpty() ? "**none**" : message.to().first().addressee()); |
|
263 qDebug() << "Body:" <<message.textContent(); |
|
264 } |
|
265 |
|
266 |
|
267 void EventLoggerEngine::notification(int eventId, QString service,QMessageStorePrivate::NotificationType notificationType) |
|
268 { |
|
269 |
|
270 |
|
271 QMessageManager::NotificationFilterIdSet matchingFilters; |
|
272 // qDebug() << "EventLoggerEngine::notification id=" << eventId; |
|
273 |
|
274 // Copy the filter map to protect against modification during traversal |
|
275 QMap<int, QMessageFilter> filters(_filters); |
|
276 QMap<int, QMessageFilter>::const_iterator it = filters.begin(), end = filters.end(); |
|
277 QMessage msg; |
|
278 bool messageRetrieved = false; |
|
279 |
|
280 for ( ; it != end; ++it) { |
|
281 const QMessageFilter &filter(it.value()); |
|
282 if (filter.isEmpty()) { |
|
283 // Empty filter matches to all messages |
|
284 matchingFilters.insert(it.key()); |
|
285 } else { |
|
286 QMessageFilterPrivate* privateMessageFilter = QMessageFilterPrivate::implementation(filter); |
|
287 if (!messageRetrieved && (privateMessageFilter->_field == QMessageFilterPrivate::Type)) { |
|
288 if (service == "RTCOM_EL_SERVICE_SMS") { |
|
289 msg.setType(QMessage::Sms); |
|
290 } else if (service== "RTCOM_EL_SERVICE_CHAT") { |
|
291 msg.setType(QMessage::InstantMessage); |
|
292 } else { |
|
293 msg.setType(QMessage::NoType); // Other type, as eample voice calll |
|
294 } |
|
295 } |
|
296 else if (!messageRetrieved) { |
|
297 msg = this->message(QMessageId(QString("el")+QString::number(eventId))); |
|
298 if (msg.type() == QMessage::NoType) { |
|
299 matchingFilters.clear(); |
|
300 break; |
|
301 } else { |
|
302 messageRetrieved = true; |
|
303 } |
|
304 } |
|
305 if (privateMessageFilter->filter(msg)) { |
|
306 matchingFilters.insert(it.key()); |
|
307 } |
|
308 } |
|
309 } |
|
310 |
|
311 if (matchingFilters.count() > 0) { |
|
312 ipMessageStorePrivate->messageNotification(notificationType, |
|
313 QMessageId(QString("el")+QString::number(eventId)), |
|
314 matchingFilters); |
|
315 } |
|
316 |
|
317 } |
|
318 |
|
319 #if 0 |
|
320 QMessageIdList EventLoggerEngine::filterAndOrderMessages(const QMessageFilter &filter, const QMessageSortOrder& sortOrder, |
|
321 QString body, QMessageDataComparator::MatchFlags matchFlags) |
|
322 { |
|
323 filterAndOrderMessages(filte, sortOrder, body, matchFlags); |
|
324 } |
|
325 #endif |
|
326 |
|
327 bool EventLoggerEngine::filterMessages(const QMessageFilter &filter, |
|
328 const QMessageSortOrder& sortOrder, |
|
329 QString body, |
|
330 QMessageDataComparator::MatchFlags matchFlags) |
|
331 { |
|
332 |
|
333 // qDebug() << "EventLoggerEngine::filterMessages"; |
|
334 if (active) { |
|
335 qWarning() << "EventLoggerEngine::filterMessages::Service is currently busy"; |
|
336 return false; |
|
337 } |
|
338 |
|
339 |
|
340 active = true; |
|
341 state = QMessageService::ActiveState; |
|
342 emit stateChanged(state); |
|
343 |
|
344 if(!queryThread) { |
|
345 queryThread=new QueryThread(); |
|
346 connect(queryThread, SIGNAL(completed()), this, SLOT(reportMatchingIds()), Qt::QueuedConnection); |
|
347 }; |
|
348 queryThread->setArgs(this, filter, body, matchFlags, sortOrder, 0,0); |
|
349 queryThread->start(); |
|
350 |
|
351 // return queryThread.queryMessages(filter,sortOrder,body,matchFlags); |
|
352 return true; |
|
353 } |
|
354 |
|
355 void EventLoggerEngine::messagesFound_(const QMessageIdList &ids) |
|
356 { |
|
357 // qDebug() << "EventLoggerEngine::messagesFound"; |
|
358 emit messagesFound(ids,true,false); // filtered but not sorted |
|
359 } |
|
360 |
|
361 |
|
362 void EventLoggerEngine::reportMatchingIds() |
|
363 { |
|
364 // qDebug() << "EventLoggerEngine::messagesFound" << m_ids.count(); |
|
365 emit messagesFound(m_ids,true,false); |
|
366 completed(); |
|
367 } |
|
368 |
|
369 void EventLoggerEngine::completed() |
|
370 { |
|
371 active = false; |
|
372 state = QMessageService::FinishedState; |
|
373 emit stateChanged(state); |
|
374 } |
|
375 |
|
376 |
|
377 QMessageIdList EventLoggerEngine::filterAndOrderMessages(const QMessageFilter &filter, |
|
378 const QMessageSortOrder& sortOrder, |
|
379 QString body, |
|
380 QMessageDataComparator::MatchFlags matchFlags) |
|
381 { |
|
382 Q_UNUSED(body); |
|
383 Q_UNUSED(matchFlags); |
|
384 Q_UNUSED(sortOrder); |
|
385 QMessageId fId; // Filtering id |
|
386 // QMessageType fType; |
|
387 QDate fDate; |
|
388 RTComElEvent ev; |
|
389 QMessage message; |
|
390 |
|
391 const char *services[]={"RTCOM_EL_SERVICE_CHAT","RTCOM_EL_SERVICE_SMS", NULL }; |
|
392 |
|
393 QMessageIdList idList; |
|
394 |
|
395 QMessageFilterPrivate* pf = QMessageFilterPrivate::implementation(filter); |
|
396 #if 0 |
|
397 if ((filters.count() == 1) && (pf->_field == QMessageFilterPrivate::None) && (pf->_filterList.count() == 0)) { |
|
398 if (pf->_notFilter) { |
|
399 // There is only one filter: empty ~QMessageFilter() |
|
400 // => return empty QMessageIdList |
|
401 return idList; |
|
402 } else { |
|
403 // There is only one filter: empty QMessageFilter() |
|
404 // => return all messages |
|
405 |
|
406 } |
|
407 } |
|
408 // Pre-filtering setup |
|
409 switch (pf->_field) { |
|
410 case QMessageFilterPrivate::Id: |
|
411 case QMessageFilterPrivate::ParentAccountId: |
|
412 { |
|
413 if (pf->_comparatorType == QMessageFilterPrivate::Equality) { // QMessageAccountId |
|
414 iNumberOfHandledFilters++; |
|
415 QMessageDataComparator::EqualityComparator cmp(static_cast<QMessageDataComparator::EqualityComparator>(pf->_comparatorValue)); |
|
416 if (cmp == QMessageDataComparator::Equal) { |
|
417 QMessageAccount messageAccount = TelepathyEngine::instance()->account(QMessageAccountId(QString("/y/Account%1").arg(pf->_value.toString()))); |
|
418 } |
|
419 } |
|
420 } |
|
421 } |
|
422 #endif |
|
423 RTComElQuery *q=rtcom_el_query_new(el); |
|
424 rtcom_el_query_prepare(q,"service", services, RTCOM_EL_OP_IN_STRV, NULL); |
|
425 RTComElIter *iter=rtcom_el_get_events(el,q); |
|
426 g_object_unref(q); |
|
427 if(iter && rtcom_el_iter_first(iter)) |
|
428 do { |
|
429 bzero(&ev,sizeof(ev)); |
|
430 if(rtcom_el_iter_get_full(iter,&ev)) |
|
431 { |
|
432 message=eventToMessage(ev); |
|
433 // debugMessage(message); |
|
434 if (pf->filter(message)) { |
|
435 // qDebug() <<"Filter :filtering match" << message.id().toString(); |
|
436 //matchingFilters.insert(it.key()); |
|
437 idList.append(message.id()); |
|
438 }; |
|
439 }; |
|
440 } |
|
441 while( rtcom_el_iter_next(iter)); |
|
442 #if 0 |
|
443 foreach(const QMessageId& id, idList) { |
|
444 qDebug() << "id=" << id.toString(); |
|
445 } |
|
446 #endif |
|
447 return idList; |
|
448 } |
|
449 |
|
450 |
|
451 QueryThread::QueryThread(): QThread() |
|
452 { |
|
453 } |
|
454 |
|
455 void QueryThread::setArgs(EventLoggerEngine *parent, const QMessageFilter &filter, const QString &body, QMessageDataComparator::MatchFlags matchFlags, const QMessageSortOrder &sortOrder, uint limit, uint offset) |
|
456 { |
|
457 _parent=parent; |
|
458 _filter=filter; |
|
459 _body=body; |
|
460 _matchFlags=matchFlags; |
|
461 _sortOrder=sortOrder; |
|
462 _limit=limit; |
|
463 _offset=offset; |
|
464 } |
|
465 |
|
466 void QueryThread::run() |
|
467 { |
|
468 // qDebug() << "QueryThread::run()"; |
|
469 _parent->m_ids=EventLoggerEngine::instance()->filterAndOrderMessages(_filter,_sortOrder,_body,_matchFlags); |
|
470 // qDebug() << "QueryThread::run() done" << _parent->m_ids.count(); |
|
471 emit completed(); |
|
472 } |
|
473 |
|
474 |
|
475 |
|
476 #include "moc_eventloggerengine_maemo_p.cpp" |
|
477 |
|
478 QTM_END_NAMESPACE |