examples/ForumNokia/Symbian_OS_End-to-End_Sockets_API_Example/SocketTaskManager/inc/TaskManagerEngine.h

/*
 * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.
 *    
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *    
 *  * Redistributions of source code must retain the above copyright notice, this
 *    list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 *  * Neither the name of Nokia Corporation nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *    
 *    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 *    AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 *    DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
 *    FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 *    DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 *    SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 *    CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 *    OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 *    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *    
 *    Description:  
 */

#ifndef __TASKMANAGERENGINE_H
#define __TASKMANAGERENGINE_H

// INCLUDE FILES
#include "TaskManager.hrh"
#include "TaskManagerEngineReader.h"
#include "timeouttimer.h"
#include "request.h"

#include <in_sock.h>                                            //TInetAddr
#include <msvapi.h>                                                     //MMsvSessionObserver
#include <cdblen.h>                                                     //KCommsDbSvrMaxFieldLength
#include <es_sock.h>                                            //TSockXfrLength

// FORWARD DECLARATIONS
class CSecureSocket;
class CResponse;

// CLASS DECLARATION

class MTransactionObserver
        {
public:
        virtual void OpeningConnectionL() = 0;
        
        virtual void SuccessL(const CResponse& aResponse) = 0;
        
        virtual void FailedL(const TInt& aError) = 0;
        
        virtual void ConnectingToServerL(const TBool& aLoadingTasks) = 0;
        
        virtual void CancelledL() = 0;
        
        virtual void ErrorL(const TDesC& aErrorMsg) = 0;
        };

// CLASS DECLARATION

class TIap
        {
public:
        TUint32 iId;
        TBuf<KCommsDbSvrMaxFieldLength> iName;
        };
        

// CLASS DECLARATION

class CTaskManagerEngine :      public CActive,
                                                        public MMsvSessionObserver,
                                                        public MEngineNotifier,
                                                        public MTimeoutNotifier
        {
public: // Constructors and destructor

        static CTaskManagerEngine* NewL(MTransactionObserver& aObserver);

        ~CTaskManagerEngine();
        
protected: // from CActive

   void DoCancel();

   void RunL();
   
   TInt RunError( TInt aError );
        
public: // Main interface for engine logic
        
        void SetConnectionSettings(const TDesC& aServerName, 
                                                                const TInt& aPort,
                                                                const TDesC& aUsername, 
                                                                const TDesC& aPassword);
                                                                
        void FetchTasksL();
        
        void MarkTaskDoneL(const TInt& aTaskId);

        void CheckRefreshL();

public: // from MEngineNotifier

    TBool PackageReceivedL( const TDesC8& aData );

public: // MTimeoutNotifier

    void TimerExpired();

public: // New functions

        void SetIap(const TUint32& aId);
        
        void CancelTransaction();
        
        TBool IapSet() const;
        
        RArray<TIap>& Iaps();

    void SetAutomaticUpdateL(const TBool& aOn);
        
private: // Functions from base classes

        void HandleSessionEventL(TMsvSessionEvent aEvent, TAny* aArg1, TAny* aArg2, TAny* aArg3);
                
private: // New functions

        void LoadIapsL();
        
        void ConnectL();
        
        void ConnectL( TUint32 aAddr );
        
        TBool CheckAndReportErrorsL();
        
        void GPRSConnectL();
        
        void EndConnection();
        
private:

        CTaskManagerEngine(MTransactionObserver& aObserver);
        void ConstructL();
        
        enum TEngineState
                {
                // Connection enums
                ENotConnected = 1,
                EStartingGPRS,
        ELookingUp,
                EConnecting,
                ESSLConnecting,
                EConnected,
                
                // Transmission enums
                EWriting,
                EReading
                };
        
private: // Data members

    // Timeout-constant, defined in .cpp
    static const TInt           KTimeOut;

    // Socket handles and variables
        RSocketServ                                     iSocketServer;
        RSocket                                         iSocket;
        RConnection                                     iConnection;
        CSecureSocket*              iSecureSocket;
        TInetAddr                                       iAddress;

    // State of engine
        TEngineState                            iState;
        
    // Timeout timer
        CTimeOutTimer*              iTimer;
        
        // Which operation is being performed
        TRequest::TOperationType        iOperation;
        
        // If the operation is "mark task", the id of
        // the task is stored here.
        TBuf<5>                                         iMarkId;
        
        // DNS resolver
        RHostResolver                           iResolver;

        // Result from DNS resolver
        TNameEntry                                      iNameEntry;
        TNameRecord                             iNameRecord;

    // Message server observation
        CMsvSession*                            iMsvSession;
        CMsvEntry*                                      iMsvEntry;

    // Handle to inform view
        MTransactionObserver&           iTransactionObserver;
        
        // User variables
        TBuf<KMaxUsernameLength>        iUsername;
        TBuf<KMaxPasswordLength>        iPassword;
        TBuf<KMaxServerNameLength>      iServer;
        TInt                                            iPort;
        
        // Write message buffer
        TBuf8<KMaxWriteBufferSize>      iWriteBuffer;
        
        // Active object for reading inbound streams
    CTaskManagerEngineReader*   iReader;
    
        // Parser class, hides the structure of messages from the engine
        CResponse*                  iResponse;
        
        // The amount of data read is stored here
        TSockXfrLength                          iDummyLength;
        
        TBool                                           iRunning;
        TBool                                           iDoRefresh;
        TBool                       iOpeningConnection;
        RArray<TIap>                            iIAPs;
        TUint32                                         iIap;
        TBool                                           iAutomaticUpdate;
        };

#endif

// End of file

---