1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 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 #include "qmessageservice.h"

    42 #include "modestengine_maemo_p.h"

    43 #include "telepathyengine_maemo_p.h"

    44 #include <QDebug>

    45 

    46 QTM_BEGIN_NAMESPACE

    47 

    48 class QMessageServicePrivate : public QObject

    49 {

    50 public:

    51     QMessageServicePrivate(QMessageService* parent);

    52     ~QMessageServicePrivate();

    53 

    54     void setFinished(bool successful);

    55 

    56 public:

    57     QMessageService* q_ptr;

    58     QMessageService::State _state;

    59     bool _active;

    60     QMessageManager::Error _error;

    61 };

    62 

    63 QMessageServicePrivate::QMessageServicePrivate(QMessageService* parent)

    64  : q_ptr(parent),

    65    _state(QMessageService::InactiveState),

    66    _active(false)

    67 {

    68 }

    69 

    70 QMessageServicePrivate::~QMessageServicePrivate()

    71 {

    72 }

    73 

    74 QMessageService::QMessageService(QObject *parent)

    75  : QObject(parent),

    76    d_ptr(new QMessageServicePrivate(this))

    77 {

    78 }

    79 

    80 void QMessageServicePrivate::setFinished(bool successful)

    81 {

    82     if (!successful && (_error == QMessageManager::NoError)) {

    83         // We must report an error of some sort

    84         _error = QMessageManager::RequestIncomplete;

    85     }

    86 

    87     _state = QMessageService::FinishedState;

    88     emit q_ptr->stateChanged(_state);

    89     _active = false;

    90 }

    91 

    92 QMessageService::~QMessageService()

    93 {

    94 }

    95 

    96 bool QMessageService::queryMessages(const QMessageFilter &filter, const QMessageSortOrder &sortOrder, uint limit, uint offset)

    97 {

    98     if (d_ptr->_active) {

    99         return false;

   100     }

   101 

   102     d_ptr->_active = true;

   103     d_ptr->_error = QMessageManager::NoError;

   104 

   105     if (ModestEngine::instance()->queryMessages(*this, filter, sortOrder, limit, offset)) {

   106         d_ptr->_state = QMessageService::ActiveState;

   107         emit stateChanged(d_ptr->_state);

   108     } else {

   109         d_ptr->setFinished(false);

   110     }

   111 

   112     return d_ptr->_active;

   113 }

   114 

   115 bool QMessageService::queryMessages(const QMessageFilter &filter, const QString &body, QMessageDataComparator::MatchFlags matchFlags, const QMessageSortOrder &sortOrder, uint limit, uint offset)

   116 {

   117     if (d_ptr->_active) {

   118         return false;

   119     }

   120 

   121     d_ptr->_active = true;

   122     d_ptr->_error = QMessageManager::NoError;

   123 

   124     if (ModestEngine::instance()->queryMessages(*this, filter, body, matchFlags, sortOrder, limit, offset)) {

   125         d_ptr->_state = QMessageService::ActiveState;

   126         emit stateChanged(d_ptr->_state);

   127     } else {

   128         d_ptr->setFinished(false);

   129     }

   130 

   131     return d_ptr->_active;

   132 }

   133 

   134 bool QMessageService::countMessages(const QMessageFilter &filter)

   135 {

   136     if (d_ptr->_active) {

   137         return false;

   138     }

   139 

   140     d_ptr->_active = true;

   141     d_ptr->_error = QMessageManager::NoError;

   142 

   143     if (ModestEngine::instance()->countMessages(*this, filter)) {

   144         d_ptr->_state = QMessageService::ActiveState;

   145         emit stateChanged(d_ptr->_state);

   146     } else {

   147         d_ptr->setFinished(false);

   148     }

   149 

   150     return d_ptr->_active;

   151 }

   152 

   153 bool QMessageService::send(QMessage &message)

   154 {

   155     if (d_ptr->_active) {

   156         return false;

   157     }

   158 

   159     d_ptr->_active = true;

   160     d_ptr->_error = QMessageManager::NoError;

   161 

   162     bool retVal = true;

   163 

   164     d_ptr->_state = QMessageService::ActiveState;

   165     emit stateChanged(d_ptr->_state);

   166 

   167     // Check message type

   168     if(message.type() == QMessage::AnyType || message.type() == QMessage::NoType) {

   169         d_ptr->_error = QMessageManager::ConstraintFailure;

   170         retVal = false;

   171     }

   172 

   173     QMessageAccountId accountId = message.parentAccountId();

   174     if (retVal) {

   175         // Check account

   176         if (!accountId.isValid()) {

   177             accountId = QMessageAccount::defaultAccount(message.type());

   178             if (!accountId.isValid()) {

   179                 d_ptr->_error = QMessageManager::InvalidId;

   180                 retVal = false;

   181             }

   182         }

   183     }

   184 

   185     QMessageAccount account(accountId);

   186     if (retVal) {

   187         // Check account/message type compatibility

   188         if (!(account.messageTypes() & message.type())) {

   189             d_ptr->_error = QMessageManager::ConstraintFailure;

   190             retVal = false;

   191         }

   192     }

   193 

   194     if (retVal) {

   195         // Check recipients

   196         QMessageAddressList recipients = message.to() + message.bcc() + message.cc();

   197         if (recipients.isEmpty()) {

   198             d_ptr->_error = QMessageManager::ConstraintFailure;

   199             return false;

   200         }

   201     }

   202 

   203     QMessage outgoing(message);

   204 

   205     // Set default account if unset

   206     if (!outgoing.parentAccountId().isValid()) {

   207         outgoing.setParentAccountId(accountId);

   208     }

   209 

   210     if (retVal) {

   211         if (account.messageTypes() & QMessage::Sms) {

   212             retVal = TelepathyEngine::instance()->sendMessage(message);

   213         } else if (account.messageTypes() & QMessage::Xmpp) {

   214             retVal = TelepathyEngine::instance()->sendMessage(message);

   215         } else if (account.messageTypes() & QMessage::Mms) {

   216             d_ptr->_error = QMessageManager::NotYetImplemented;

   217             qWarning() << "QMessageService::send not yet implemented for MMS";

   218             retVal = false;

   219         } else if (account.messageTypes() & QMessage::Email) {

   220             retVal = ModestEngine::instance()->sendEmail(message);

   221         }

   222     }

   223 

   224     d_ptr->setFinished(retVal);

   225     return retVal;

   226 }

   227 

   228 bool QMessageService::compose(const QMessage &message)

   229 {

   230     if (d_ptr->_active) {

   231         return false;

   232     }

   233 

   234     d_ptr->_active = true;

   235     d_ptr->_error = QMessageManager::NoError;

   236 

   237     bool retVal = true;

   238     d_ptr->_state = QMessageService::ActiveState;

   239     emit stateChanged(d_ptr->_state);

   240 

   241     if (message.type() == QMessage::Sms) {

   242         d_ptr->_error = QMessageManager::NotYetImplemented; //TODO:

   243         qWarning() << "QMessageService::compose not yet implemented for SMS";

   244         retVal = false;

   245     } else if (message.type() == QMessage::Mms) {

   246         d_ptr->_error = QMessageManager::NotYetImplemented; //TODO:

   247         qWarning() << "QMessageService::compose not yet implemented for MMS";

   248         retVal = false;

   249     } else if (message.type() == QMessage::Email) {

   250         retVal = ModestEngine::instance()->composeEmail(message);

   251     }

   252 

   253     d_ptr->setFinished(retVal);

   254     return retVal;

   255 }

   256 

   257 bool QMessageService::retrieveHeader(const QMessageId& id)

   258 {

   259     Q_UNUSED(id)

   260     return false; // stub

   261 }

   262 

   263 bool QMessageService::retrieveBody(const QMessageId& id)

   264 {

   265     Q_UNUSED(id)

   266     return false; // stub

   267 }

   268 

   269 bool QMessageService::retrieve(const QMessageId &messageId, const QMessageContentContainerId& id)

   270 {

   271     Q_UNUSED(messageId)

   272     Q_UNUSED(id)

   273     return false; // stub

   274 }

   275 

   276 bool QMessageService::show(const QMessageId& id)

   277 {

   278     Q_UNUSED(id)

   279     return false; // stub

   280 }

   281 

   282 bool QMessageService::exportUpdates(const QMessageAccountId &id)

   283 {

   284     Q_UNUSED(id)

   285     return false; // stub

   286 }

   287 

   288 QMessageService::State QMessageService::state() const

   289 {

   290     return InactiveState; // stub

   291 }

   292 

   293 void QMessageService::cancel()

   294 {

   295 }

   296 

   297 QMessageManager::Error QMessageService::error() const

   298 {

   299     return QMessageManager::NoError;

   300 }

   301 

   302 QTM_END_NAMESPACE