1 // Copyright (c) 2008-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 // This file contains all the interfaces classes that can be implemented by

    15 // the Licensee LTSY relating to Sms related features.

    16 //

    17 

    18 

    19 

    20 

    21 /**

    22  @file

    23  @internalAll 

    24 */

    25 

    26 

    27 #ifndef MLTSYDISPATCHSMSINTERFACE_H_

    28 #define MLTSYDISPATCHSMSINTERFACE_H_

    29 

    30 #include <ctsy/ltsy/mltsydispatchinterface.h>

    31 #include <etelmm.h>

    32 

    33 namespace DispatcherSim

    34 	{

    35 	

    36 	/**

    37 	 * This namespace contains all types relating to the Sim dispatcher.

    38 	 */

    39 

    40 	/** SMS parameters */

    41 	struct TSmsParameters

    42 	    {

    43 	    /*

    44 	     * LocationNumber

    45 	     */    

    46 	    TUint8 iLocationNumber;

    47 

    48 	    /*

    49 	     * Parameter Indicator

    50 	     */    

    51 	    TUint8 iParameterIndicator;

    52 

    53 	    /*

    54 	     * ProtocolId

    55 	     */    

    56 	    TUint8 iProtocolId;

    57 

    58 	    /*

    59 	     * Data Coding Scheme

    60 	     */    

    61 	    TUint8 iDataCodingScheme;

    62 

    63 	    /*

    64 	     * Validity Period

    65 	     */    

    66 	    TUint8 iValidityPeriod;

    67 

    68 	    /*

    69 	     * MobileSc TON

    70 	     */    

    71 	    RMobilePhone::TMobileTON iMobileScTON;

    72 

    73 	    /*

    74 	     * MobileSc NPI

    75 	     */    

    76 	    RMobilePhone::TMobileNPI iMobileScNPI;

    77 

    78 	     /*

    79 	     * Mobile De TON

    80 	     */    

    81 	    RMobilePhone::TMobileTON iMobileDeTON;

    82 

    83 	    /*

    84 	     * Mobile De NPI

    85 	     */    

    86 	    RMobilePhone::TMobileNPI iMobileDeNPI;

    87 

    88 	    /*

    89 	     * Alpha Tag Present

    90 	     */    

    91 	    TBool iAlphaTagPresent;

    92 	    };	

    93 	}

    94 

    95 class MLtsyDispatchSmsSendSatSms : public MLtsyDispatchInterface

    96 	{

    97 public:

    98 

    99 	static const TInt KLtsyDispatchSmsSendSatSmsApiId = KDispatchSmsFuncUnitId + 1;

   100 

   101 	/**

   102 	 * The CTSY Dispatcher shall invoke this function on receiving the EMmTsySmsSendSatMessage

   103 	 * request from the CTSY.

   104 	 *

   105 	 * It is a request call that is completed by invoking

   106 	 * CCtsyDispatcherCallback::CallbackSmsSendSatSmsComp()

   107 	 *

   108 	 * Implementation of this interface should handle a request to send a SMS message initiated from a client

   109 	 * side RSat::SendMessageNoLogging() call.

   110 	 *

   111 	 * @param aDestination The mobile telephone number.

   112 	 * @param aSmsTpdu The SMS TPDU.

   113 	 * @param aDataFormat The SMS data format.

   114 	 * @param aGsmServiceCentre The service centre number.

   115 	 * @param aMore  This indicates whether the client is going to send another SMS immediately 

   116 	                 after this one.

   117 	 *

   118 	 * @return KErrNone on success, otherwise another error code indicating the

   119 	 * failure.

   120 	 */

   121 	virtual TInt HandleSendSatSmsReqL( const TDesC8& aSmsTpdu,

   122 										   RMobileSmsMessaging::TMobileSmsDataFormat aDataFormat,

   123 										   const RMobilePhone::TMobileAddress& aGsmServiceCentre,

   124 										   TBool aMoreMessages

   125 										  ) = 0;

   126 	

   127 	}; // class MLtsyDispatchSmsSendSatSms

   128 

   129 

   130 

   131 class MLtsyDispatchSmsGetSmsStoreInfo : public MLtsyDispatchInterface

   132 	{

   133 public:

   134 

   135 	static const TInt KLtsyDispatchSmsGetSmsStoreInfoApiId = KDispatchSmsFuncUnitId + 2;

   136 

   137 	/**

   138 	 * The CTSY Dispatcher shall invoke this function on receiving the EMobileSmsMessagingGetMessageStoreInfo

   139 	 * request from the CTSY.

   140 	 *

   141 	 * It is a request call that is completed by invoking

   142 	 * CCtsyDispatcherCallback::CallbackSmsGetSmsStoreInfoComp()

   143 	 *

   144 	 * Implementation of this interface should retrieve the current Sms store information.

   145 	 *

   146 	 *

   147 	 * @return KErrNone on success, otherwise another error code indicating the

   148 	 * failure.

   149 	 * 

   150 	 * @see RMobileSmsMessaging::GetMessageStoreInfo

   151 	 */

   152 	virtual TInt HandleGetSmsStoreInfoReqL() = 0;

   153 

   154 	}; // class MLtsyDispatchSmsGetSmsStoreInfo

   155 

   156 

   157 

   158 class MLtsyDispatchSmsGetSmspList : public MLtsyDispatchInterface

   159 	{

   160 public:

   161 

   162 	static const TInt KLtsyDispatchSmsGetSmspListApiId = KDispatchSmsFuncUnitId + 3;

   163 

   164 	/**

   165 	 * The CTSY Dispatcher shall invoke this function on receiving the EMobileSmsMessagingGetSmspListPhase1

   166 	 * request from the CTSY.

   167 	 *

   168 	 * It is a request call that is completed by invoking

   169 	 * CCtsyDispatcherCallback::CallbackSmsGetSmspListComp()

   170 	 *

   171 	 * Implementation of this interface should request to read the SMS parameter list from the SIM's SMSP store.

   172 	 *

   173 	 *

   174 	 * @return KErrNone on success, otherwise another error code indicating the

   175 	 * failure.

   176 	 * 

   177 	 * @see CMobilePhoneSmspList()

   178 	 * @see CRetrieveMobilePhoneSmspList()

   179 	 */

   180 	virtual TInt HandleGetSmspListReqL() = 0;

   181 

   182 	}; // class MLtsyDispatchSmsGetSmspList

   183 

   184 

   185 

   186 class MLtsyDispatchSmsNackSmsStored : public MLtsyDispatchInterface

   187 	{

   188 public:

   189 

   190 	static const TInt KLtsyDispatchSmsNackSmsStoredApiId = KDispatchSmsFuncUnitId + 4;

   191 

   192 	/**

   193 	 * The CTSY Dispatcher shall invoke this function on receiving the EMobileSmsMessagingNackSmsStored

   194 	 * request from the CTSY.

   195 	 *

   196 	 * It is a request call that is completed by invoking

   197 	 * CCtsyDispatcherCallback::CallbackSmsNackSmsStoredComp()

   198 	 * 

   199 	 * Implementation of this interface should accept this negative acknowledgment: when the client receives an unstored SMS,

   200 	 * it will use this member function to return a negative acknowledgment if it fails to decode and/or store that SMS.

   201 	 * This TPDU will contain the TP error cause that prevents the client from acknowledging the SMS. 

   202 	 * The client should also provide the RP error cause by placing it in the aRpCause parameter.

   203 	 *

   204 	 * @param aTpdu Holds the TPDU defined for a SMS-DELIVER-REPORT (for RP-ERROR) in GSM 03.40.

   205 	 * @param aRpCause Contain one of the MS related extended error codes.

   206 	 *

   207 	 * @return KErrNone on success, otherwise another error code indicating the

   208 	 * failure.

   209 	 * 

   210 	 * @see RMobileSmsMessaging::NackSmsStored()

   211 	 */

   212 	virtual TInt HandleNackSmsStoredReqL(const TDesC8& aTpdu, TInt aRpCause) = 0;

   213 

   214 	/**

   215 	 * The CTSY Dispatcher shall invoke this function on receiving the EMobileSmsMessagingNackSmsStored

   216 	 * request from the CTSY.

   217 	 *

   218 	 * It is a request call that is completed by invoking

   219 	 * CCtsyDispatcherCallback::CallbackSmsNackSmsStoredComp()

   220 	 * 

   221 	 * Implementation of this interface should accept this negative acknowledgment: when the client receives an unstored SMS,

   222 	 * it will use this member function to return a negative acknowledgment if it fails to decode and/or store that SMS.

   223 	 * The client should also provide the RP error cause by placing it in the aRpCause parameter.

   224 	 *

   225 	 * @param aRpCause Contain one of the MS related extended error codes.

   226 	 *

   227 	 * @return KErrNone on success, otherwise another error code indicating the

   228 	 * failure.

   229 	 * 

   230 	 * @see RMobileSmsMessaging::NackSmsStored()

   231 	 */

   232 	virtual TInt HandleNackSmsStoredReqL(TInt aRpCause) = 0;

   233 

   234 	}; // class MLtsyDispatchSmsNackSmsStored

   235 

   236 

   237 

   238 class MLtsyDispatchSmsAckSmsStored : public MLtsyDispatchInterface

   239 	{

   240 public:

   241 

   242 	static const TInt KLtsyDispatchSmsAckSmsStoredApiId = KDispatchSmsFuncUnitId + 5;

   243 

   244 	/**

   245 	 * The CTSY Dispatcher shall invoke this function on receiving the EMobileSmsMessagingAckSmsStored

   246 	 * request from the CTSY.

   247 	 *

   248 	 * It is a request call that is completed by invoking

   249 	 * CCtsyDispatcherCallback::CallbackSmsAckSmsStoredComp()

   250 	 * 

   251 	 * Implementation of this interface should accept the acknowledgment: when the client receives an unstored SMS, 

   252 	 * it will trigger this function to return a positive acknowledgment if it manages to successfully decode and store that SMS.

   253 	 * If the client wishes to send a SMS-DELIVER-REPORT in response to the received SMS-DELIVER , 

   254 	 * then the aTpdu parameter will be used to hold the TPDU defined for a SMS-DELIVER-REPORT (for RP-ACK) in GSM 03.40. 

   255 	 *

   256 	 * 

   257 	 * @param aTpdu Holds the TPDU defined for a SMS-DELIVER-REPORT (for RP-ACK) in GSM 03.40.

   258 	 *

   259 	 * @return KErrNone on success, otherwise another error code indicating the

   260 	 * failure.

   261 	 * 

   262 	 * @see RMobileSmsMessaging::AckSmsStored()

   263 	 */

   264 	virtual TInt HandleAckSmsStoredReqL(const TDesC8& aTpdu) = 0;

   265 	

   266 	/**

   267 	 * The CTSY Dispatcher shall invoke this function on receiving the EMobileSmsMessagingAckSmsStored

   268 	 * request from the CTSY.

   269 	 *

   270 	 * It is a request call that is completed by invoking

   271 	 * CCtsyDispatcherCallback::CallbackSmsAckSmsStoredComp()

   272 	 * 

   273 	 * Implementation of this interface should accept the acknowledgment: when the client receives an unstored SMS, 

   274 	 * it will trigger this function to return a positive acknowledgment if it manages to successfully decode and store that SMS.

   275 	 *

   276 	 * 

   277 	 * @return KErrNone on success, otherwise another error code indicating the

   278 	 * failure.

   279 	 * 

   280 	 * @see RMobileSmsMessaging::AckSmsStored()

   281 	 */

   282 	virtual TInt HandleAckSmsStoredReqL() = 0;

   283 

   284 	}; // class MLtsyDispatchSmsAckSmsStored

   285 

   286 

   287 

   288 class MLtsyDispatchSmsResumeSmsReception : public MLtsyDispatchInterface

   289 	{

   290 public:

   291 

   292 	static const TInt KLtsyDispatchSmsResumeSmsReceptionApiId = KDispatchSmsFuncUnitId + 6;

   293 

   294 	/**

   295 	 * The CTSY Dispatcher shall invoke this function on receiving the EMobileSmsMessagingResumeSmsReception

   296 	 * request from the CTSY.

   297 	 *

   298 	 * It is a request call that is completed by invoking

   299 	 * CCtsyDispatcherCallback::CallbackSmsResumeSmsReceptionComp()

   300 	 *

   301 	 * Implementation of this interface should allow a client to resume sms reception 

   302 	 *

   303 	 * @return KErrNone on success, otherwise another error code indicating the

   304 	 * failure.

   305 	 */

   306 	virtual TInt HandleResumeSmsReceptionReqL() = 0;

   307 

   308 	}; // class MLtsyDispatchSmsResumeSmsReception

   309 

   310 

   311 class MLtsyDispatchSmsSendSmsMessage : public MLtsyDispatchInterface

   312 	{

   313 public:

   314 

   315 	static const TInt KLtsyDispatchSmsSendSmsMessageApiId = KDispatchSmsFuncUnitId + 7;

   316 

   317 	/**

   318 	 * The CTSY Dispatcher shall invoke this function on receiving the EMobileSmsMessagingSendMessage

   319 	 * request from the CTSY.

   320 	 * 

   321 	 * It is a request call that is completed by invoking

   322 	 * CCtsyDispatcherCallback::CallbackSmsSendSmsMessageComp()

   323 	 * 

   324 	 * Implementation of this interface should allow a client to send a SMS message 

   325 	 * 

   326 	 * @param aDestination The mobile telephone number.

   327 	 * @param aSmsTpdu The SMS TPDU.

   328 	 * @param aDataFormat The SMS data format.

   329 	 * @param aGsmServiceCentre The service centre number.

   330 	 * @param aMore  This indicates whether the client is going to send another SMS immediately 

   331 	 *                after this one.

   332 	 *

   333 	 * @return KErrNone on success, otherwise another error code indicating the

   334 	 * failure.

   335 	 */

   336 	virtual TInt HandleSendSmsMessageReqL( const RMobilePhone::TMobileAddress& aDestination,

   337 										   const TDesC8& aSmsTpdu,

   338 										   RMobileSmsMessaging::TMobileSmsDataFormat aDataFormat,

   339 										   const RMobilePhone::TMobileAddress& aGsmServiceCentre,

   340 										   TBool aMoreMessages

   341 										  ) = 0;

   342 

   343 

   344 	}; // class MLtsyDispatchSmsSendSmsMessage

   345 

   346 

   347 class MLtsyDispatchSmsSendSmsMessageNoFdnCheck : public MLtsyDispatchInterface

   348 	{

   349 public:

   350 

   351 	static const TInt KLtsyDispatchSmsSendSmsMessageNoFdnCheckApiId = KDispatchSmsFuncUnitId + 8;

   352 

   353 	/**

   354 	 * The CTSY Dispatcher shall invoke this function on receiving the EMobileSmsMessagingSendMessageNoFdnCheck

   355 	 * request from the CTSY.

   356 	 * 

   357 	 * It is a request call that is completed by invoking

   358 	 * CCtsyDispatcherCallback::CallbackSmsSendSmsMessageNoFdnCheckComp()

   359 	 * 

   360 	 * Implementation of this interface should allow a client to send a SMS message

   361 	 * 

   362 	 *

   363 	 * @param aDestination The mobile telephone number.

   364 	 * @param aSmsTpdu The SMS TPDU.

   365 	 * @param aDataFormat The SMS data format.

   366 	 * @param aGsmServiceCentre The service centre number.

   367 	 * @param aMore  This indicates whether the client is going to send another SMS immediately 

   368 	                 after this one.

   369 	 *

   370 	 * @return KErrNone on success, otherwise another error code indicating the

   371 	 * failure.

   372 	 */

   373 	virtual TInt HandleSendSmsMessageNoFdnCheckReqL( const RMobilePhone::TMobileAddress& aDestination,

   374 												     const TDesC8& aSmsTpdu,

   375 													 RMobileSmsMessaging::TMobileSmsDataFormat aDataFormat,

   376 													 const RMobilePhone::TMobileAddress& aGsmServiceCentre,

   377 													 TBool aMoreMessages

   378 												   ) = 0;

   379 

   380 	}; // class MLtsyDispatchSmsSendSmsMessageNoFdnCheck

   381 

   382 

   383 class MLtsyDispatchSmsSetMoSmsBearer : public MLtsyDispatchInterface

   384 	{

   385 public:

   386 

   387 	static const TInt KLtsyDispatchSmsSetMoSmsBearerApiId = KDispatchSmsFuncUnitId + 9;

   388 

   389 	/**

   390 	 * The CTSY Dispatcher shall invoke this function on receiving the EMobileSmsMessagingSetMoSmsBearer

   391 	 * request from the CTSY.

   392 	 *

   393 	 * It is a request call that is completed by invoking

   394 	 * CCtsyDispatcherCallback::CallbackSmsSetMoSmsBearerComp()

   395 	 *

   396 	 * Implementation of this interface should allow client to set SMS bearer

   397 	 * 

   398 	 * @param aBearer The SMS bearer.

   399 	 * 

   400 	 *

   401 	 * @return KErrNone on success, otherwise another error code indicating the

   402 	 * failure.

   403 	 */

   404 	virtual TInt HandleSetMoSmsBearerReqL(RMobileSmsMessaging::TMobileSmsBearer aBearer) = 0;

   405 

   406 	}; // class MLtsyDispatchSmsSetMoSmsBearer

   407 

   408 

   409 

   410 class MLtsyDispatchSmsStoreSmspListEntry : public MLtsyDispatchInterface

   411 	{

   412 public:

   413 

   414 	static const TInt KLtsyDispatchSmsStoreSmspListEntryApiId = KDispatchSmsFuncUnitId + 10;

   415 

   416 	/**

   417 	 * The CTSY Dispatcher shall invoke this function on receiving the EMobileSmsMessagingStoreSmspList

   418 	 * request from the CTSY.

   419 	 * 

   420 	 * It is a request call that is completed by invoking

   421 	 * CCtsyDispatcherCallback::CallbackSmsStoreSmspListComp()

   422 	 * 

   423 	 * Implementation of this interface should handle the request to store a SMSP entry 

   424 	 * in the SIM's SMSP file

   425 	 *

   426 	 * @param aSmspEntry Defines a set of SMS parameters

   427 	 *

   428 	 * @return KErrNone on success, otherwise another error code indicating the

   429 	 * failure.

   430 	 */

   431 	virtual TInt HandleStoreSmspListEntryReqL(const RMobileSmsMessaging::TMobileSmspEntryV1& aSmspEntry) = 0;

   432 

   433 	}; // class MLtsyDispatchSmsStoreSmspList

   434 

   435 

   436 #endif /*MLTSYDISPATCHSMSINTERFACE_H_*/