cbs/CbsServer/ClientSrc/RCbsTopicMessages.cpp
changeset 0 ff3b6d0fd310
equal deleted inserted replaced
-1:000000000000 0:ff3b6d0fd310
       
     1 /*
       
     2 * Copyright (c) 2003 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 "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:  This module contains the implementation of RCbsTopicMessages class 
       
    15                  member functions.
       
    16 *
       
    17 */
       
    18 
       
    19 
       
    20 
       
    21 // INCLUDE FILES
       
    22 
       
    23 #include "CbsServerConstants.h"
       
    24 #include "RCbs.h"
       
    25 #include "RCbsTopicMessages.h"
       
    26 
       
    27 
       
    28 // ================= MEMBER FUNCTIONS =======================
       
    29 
       
    30 // -----------------------------------------------------------------------------
       
    31 // RCbsTopicMessages::RCbsTopicMessages
       
    32 // C++ default constructor can NOT contain any code, that
       
    33 // might leave.
       
    34 // -----------------------------------------------------------------------------
       
    35 //
       
    36 RCbsTopicMessages::RCbsTopicMessages()
       
    37     {
       
    38     }
       
    39 
       
    40 // -----------------------------------------------------------------------------
       
    41 // RCbsTopicMessages::Open
       
    42 // Creates a subsession to the server.
       
    43 // (other items were commented in a header).
       
    44 // -----------------------------------------------------------------------------
       
    45 //  
       
    46 TInt RCbsTopicMessages::Open( 
       
    47     RCbs& aServer )
       
    48     {
       
    49     const TIpcArgs args( TIpcArgs::ENothing );
       
    50     return CreateSubSession( aServer, ECbsCreateTopicMessagesSubsession, args );
       
    51     }
       
    52 
       
    53 // -----------------------------------------------------------------------------
       
    54 // RCbsTopicMessages::Close
       
    55 // Closes the subsession.
       
    56 // (other items were commented in a header).
       
    57 // -----------------------------------------------------------------------------
       
    58 // 
       
    59 TInt RCbsTopicMessages::Close()
       
    60     {
       
    61     // Release locked message, if any
       
    62     TCbsMessageHandle handle( 0 );
       
    63     LockMessage( handle );
       
    64 
       
    65     // Close the subsession.
       
    66     RSubSessionBase::CloseSubSession( ECbsCloseTopicMessagesSubsession );
       
    67     return KErrNone;
       
    68     }
       
    69 
       
    70 // -----------------------------------------------------------------------------
       
    71 // RCbsTopicMessages::GetMessageCount
       
    72 // Returns the total amount of messages the topic contains.
       
    73 // (other items were commented in a header).
       
    74 // -----------------------------------------------------------------------------
       
    75 // 
       
    76 TInt RCbsTopicMessages::GetMessageCount( 
       
    77     TCbsTopicNumber aNumber, 
       
    78     TInt& aCount )
       
    79     {
       
    80     // Send request to get the total amount of messages
       
    81     aCount = 0;
       
    82     TPckgBuf< TInt > pckgCount( aCount );    
       
    83     const TIpcArgs args( aNumber, &pckgCount );
       
    84 
       
    85     TInt result = SendReceive( ECbsGetMessageCount, args );
       
    86     
       
    87     // If everything went fine, give the result to the client.
       
    88     if ( result == KErrNone )
       
    89         {
       
    90         aCount = pckgCount();
       
    91         }
       
    92     return result;
       
    93     }
       
    94     
       
    95 // -----------------------------------------------------------------------------
       
    96 // RCbsTopicMessages::GetMessage
       
    97 // Returns message information.
       
    98 // (other items were commented in a header).
       
    99 // -----------------------------------------------------------------------------
       
   100 // 
       
   101 TInt RCbsTopicMessages::GetMessage( 
       
   102     TCbsTopicNumber aNumber, 
       
   103     TInt aIndex, 
       
   104     TCbsMessage& aMessage )
       
   105     {
       
   106     // Send request to get the message from server
       
   107     TPckgBuf< TCbsMessage > pckgMessage;
       
   108     const TIpcArgs args( aNumber, aIndex, &pckgMessage );
       
   109 
       
   110     TInt result = SendReceive( ECbsGetMessage, args );
       
   111 
       
   112     if ( result == KErrNone )
       
   113         {
       
   114         aMessage = pckgMessage();
       
   115         }
       
   116     else
       
   117         {
       
   118         aMessage.iHandle = 0;
       
   119         }
       
   120 
       
   121     return result;
       
   122 
       
   123     }
       
   124 
       
   125 // -----------------------------------------------------------------------------
       
   126 // RCbsTopicMessages::FindMessageByHandle
       
   127 // Finds a message by given handle.
       
   128 // (other items were commented in a header).
       
   129 // -----------------------------------------------------------------------------
       
   130 // 
       
   131 TInt RCbsTopicMessages::FindMessageByHandle( 
       
   132     const TCbsMessageHandle& aHandle, 
       
   133     TCbsMessage& aMessage )
       
   134     {
       
   135     // Send request to the server to find a message by handle
       
   136     TPckgBuf< TCbsMessageHandle > pckgHandle( aHandle );
       
   137     TPckgBuf< TCbsMessage > pckgMessage;
       
   138     const TIpcArgs args( &pckgHandle, &pckgMessage );
       
   139 
       
   140     TInt result = SendReceive( ECbsFindMessageByHandle, args );
       
   141 
       
   142     // If everything went fine, update the message
       
   143     if ( result == KErrNone )
       
   144         {
       
   145         aMessage = pckgMessage();
       
   146         }
       
   147     else
       
   148         {
       
   149         aMessage.iHandle = 0;
       
   150         }
       
   151 
       
   152     return result;
       
   153 
       
   154     }
       
   155 
       
   156 // -----------------------------------------------------------------------------
       
   157 // RCbsTopicMessages::GetMessageIndexByHandle
       
   158 // Returns the index of a message with given handle in topic.
       
   159 // (other items were commented in a header).
       
   160 // -----------------------------------------------------------------------------
       
   161 // 
       
   162 TInt RCbsTopicMessages::GetMessageIndexByHandle( 
       
   163     const TCbsMessageHandle& aHandle, 
       
   164     TInt& aIndex )
       
   165     {
       
   166     TPckgBuf< TCbsMessageHandle > pckgHandle( aHandle );
       
   167     TPckgBuf< TInt > pckgIndex( 0 );
       
   168     const TIpcArgs args( &pckgHandle, &pckgIndex );
       
   169 
       
   170     TInt result( SendReceive( ECbsGetMessageIndexByHandle, args ) );
       
   171 
       
   172     if ( result == KErrNone )
       
   173         {
       
   174         aIndex = pckgIndex();
       
   175         }
       
   176     return result;
       
   177     }
       
   178 
       
   179 // -----------------------------------------------------------------------------
       
   180 // RCbsTopicMessages::DeleteMessage
       
   181 // Deletes an existing message.
       
   182 // (other items were commented in a header).
       
   183 // -----------------------------------------------------------------------------
       
   184 // 
       
   185 TInt RCbsTopicMessages::DeleteMessage( 
       
   186     const TCbsMessageHandle& aHandle )
       
   187     {
       
   188     // Send request to delete a message by handle
       
   189     TPckgBuf< TCbsMessageHandle > pckgHandle( aHandle );
       
   190     const TIpcArgs args( &pckgHandle );
       
   191     return SendReceive( ECbsDeleteMessage, args );
       
   192     }
       
   193 
       
   194 // -----------------------------------------------------------------------------
       
   195 // RCbsTopicMessages::SaveMessage
       
   196 // Saves a message (i.e., the saved message won't be deleted to make 
       
   197 // room for new messages).
       
   198 // (other items were commented in a header).
       
   199 // -----------------------------------------------------------------------------
       
   200 // 
       
   201 TInt RCbsTopicMessages::SaveMessage( 
       
   202     const TCbsMessageHandle& aHandle )
       
   203     {
       
   204     // Send request to save a message by handle
       
   205     TPckgBuf< TCbsMessageHandle > pckgHandle( aHandle );
       
   206     const TIpcArgs args( &pckgHandle );
       
   207     return SendReceive( ECbsSaveMessage, args );
       
   208     }
       
   209 
       
   210 // -----------------------------------------------------------------------------
       
   211 // RCbsTopicMessages::LockMessage
       
   212 // Locks the message.
       
   213 // (other items were commented in a header).
       
   214 // -----------------------------------------------------------------------------
       
   215 // 
       
   216 TInt RCbsTopicMessages::LockMessage( 
       
   217     const TCbsMessageHandle& aHandle )
       
   218     {
       
   219     TPckgBuf< TCbsMessageHandle > pckgHandle( aHandle );
       
   220     const TIpcArgs args( &pckgHandle );
       
   221     return SendReceive( ECbsLockMessage, args );
       
   222     }
       
   223 
       
   224 // -----------------------------------------------------------------------------
       
   225 // RCbsTopicMessages::ReadMessage
       
   226 // Sets the message as read.
       
   227 // (other items were commented in a header).
       
   228 // -----------------------------------------------------------------------------
       
   229 // 
       
   230 TInt RCbsTopicMessages::ReadMessage( 
       
   231     const TCbsMessageHandle& aHandle )
       
   232     {
       
   233     // Send request to set message read by handle
       
   234     TPckgBuf< TCbsMessageHandle > pckgHandle( aHandle );
       
   235     const TIpcArgs args( &pckgHandle );
       
   236     return SendReceive( ECbsReadMessage, args );
       
   237     }
       
   238 
       
   239 // -----------------------------------------------------------------------------
       
   240 // RCbsTopicMessages::GetMessageContents
       
   241 // Returns the message contents.
       
   242 // (other items were commented in a header).
       
   243 // -----------------------------------------------------------------------------
       
   244 // 
       
   245 TInt RCbsTopicMessages::GetMessageContents( 
       
   246     const TCbsMessageHandle& aHandle, 
       
   247     TDes& aBuffer )
       
   248     {
       
   249     // Send request to get the message contents
       
   250     TPckgBuf< TCbsMessageHandle > pckgHandle( aHandle );
       
   251     TInt length = aBuffer.MaxLength();
       
   252     const TIpcArgs args( &pckgHandle, length, &aBuffer );
       
   253 
       
   254     TInt result( SendReceive( ECbsGetMessageContents, args ) );
       
   255     if ( result != KErrNone )
       
   256         {
       
   257         aBuffer.Zero();
       
   258         }
       
   259     return result;
       
   260     }
       
   261 
       
   262 // -----------------------------------------------------------------------------
       
   263 // RCbsTopicMessages::GetNextAndPrevMessageHandle
       
   264 // Returns the handles of messages that precede and succeed the 
       
   265 // given message in server-side list of topic messages.
       
   266 // (other items were commented in a header).
       
   267 // -----------------------------------------------------------------------------
       
   268 // 
       
   269 TInt RCbsTopicMessages::GetNextAndPrevMessageHandle(
       
   270 	const TCbsMessageHandle& aCurrentMsgHandle,
       
   271 	TCbsMessageHandle& aPrevMsgHandle,
       
   272 	TCbsMessageHandle& aNextMsgHandle,
       
   273 	TInt& aPosition )
       
   274     {
       
   275     TPckgBuf< TCbsMessageHandle > pckgCurrentMsg( aCurrentMsgHandle );
       
   276     TPckgBuf< TCbsNextPrevMsgAndPosition > pckgResults;
       
   277     const TIpcArgs args( &pckgCurrentMsg, &pckgResults );
       
   278 
       
   279     TInt result( SendReceive( ECbsGetNextAndPrevMsgHandle, args ) );
       
   280     if ( result == KErrNone )
       
   281         {
       
   282         aPrevMsgHandle = pckgResults().iPrevMsg;
       
   283         aNextMsgHandle = pckgResults().iNextMsg;
       
   284         aPosition = pckgResults().iPosition;
       
   285         }
       
   286     return result;
       
   287     }
       
   288 
       
   289 // ================= OTHER EXPORTED FUNCTIONS ==============
       
   290 
       
   291 //  End of File