hash
stringlengths 32
32
| doc_id
stringlengths 5
12
| section
stringlengths 4
1.47k
| content
stringlengths 0
6.67M
|
|---|---|---|---|
198feca7a70995985a5cc7f203dbedb2
|
25.867
|
5.6.3 Conclusions
|
The simulations results show the impact of WDS from an RF perspective on most critical downlink parameters, with certain requirements at BS interface point.
Any effects can be measured over a range of different power classes and implementation scenarios in order to define the interface conditions required to satisfy the relevant specification.
Simulations have been limited to downlink parameters because of the utmost importance and higher criticality of this area. Reference [5] and RF performance discussion at 6.1 show that uplink parameters are less critical for WDS, while utilised technologies are of the same kind as for downlink.
ACLR testing has demonstrated that a 3dB margin is desirable to account for WDS inclusion in a system. Further work may be required to verify the recommended margin consistency for the remaining uplink parameters (e.g. Noise Figure, Blocking, and Intermodulation) and downlink parameters (e.g. Modulation Accuracy, Frequency Stability and Accuracy, Output Power Stability and Accuracy) for all scenarios, particularly in the multi-carrier case.
Out of band spurious emissions in any applicable environment are driven by the RF filtering on WDS; this will be designed to suit any of the regional requirements.
6 Network Performance Evaluation
6.1 End to End System Simulations
The potential impact on network performance and QoS connected to the deployment of WDS were assessed by means of end to end system simulations. These simulations are not intended to replace or supersede any other similar simulations that are included in other WG4 works.
Additional information can be found in reference [1], End to End Simulations Detail, TEK 3GPP ETE SD v.0.1, R4-011578].
6.2 Simulation Scenarios and Parameters
The simulations were set out to investigate whether there were impacts to the overall network performance as a result of the inclusion of a WDS.
The network performance was assessed from a comparative perspective, with and without WDS, by performing simulations in a number of scenarios relevant to the key attributes of the WDS system. The main point of focus was the network performance impact when operator site sharing, enabled by WDS, was simulated.
This was explored using a number of different scenarios and a set of parameters as detailed in [1].
6.3 Simulation Results
The details and key findings from the simulation programme are discussed in the mentioned simulation report [1].
All simulations were carried out at pedestrian velocity of 3Km/h with a data rate of 12.2 Kb/s unless otherwise stated.
6.4 Network Performance Simulation Summary
A number of scenarios have been assumed in the simulations in order to assess the implications on the overall QoS that result from the site sharing opportunities offered by WDS.
The simulations have also sought to demonstrate how the WDS can be utilised to enable greater network flexibility in terms of serving different practical scenarios. The findings are summarised in the following points.
1. The presence of two operators with equal offered traffic density and cellular layout (with equal cell radius) doesn’t cause a significant loss of quality or of capacity with respect to the single operator case.
2. The presence of WDS, which allows to share sites among operators
a. Is not detrimental when the systems are scarcely loaded, while it tends to yield increasing benefits when the offered traffic increases.
b. Is more resilient to adjacent carrier interference even when the ACS and ACLR values are substantially reduced (e.g. due to hardware failures or malfunctioning).
3. Deploying micro-cells (made possible by the introduction of WDS) allows increasing system capacity. Traffic density, which leads a system to congestion, may be served by means of an appropriate reduction of cell radius.
4. The maximum DL power can be reduced (to as low as 20 dBm) while offering satisfactory quality, provided that the cell radius is adequately reduced in order to compensate for the decreased coverage.
5. The advantages of site sharing appear more clearly when user bit rates higher than the basic 12.2 Kb/s are considered.
6. The system can accommodate mixed services with satisfactory quality, although when the data services bit rate increases there may be problems with DL quality that can be overcome by adjusting DL power.
7. The analysis of mixed layout systems (composed of both macro-cells and micro-cells) confirms that microcells can carry a traffic density significantly higher than macro-cells in spite of the higher interference they receive from neighbouring macro-cells. In this case, when terminals move faster we observe generally lower blocking and dropping probabilities, at the cost of a higher fraction of unsatisfied users.
8. The analysis of an indoor system with two operators shows that it is possible to carry a 2 Mb/s user for each operator, even in presence of a traffic “floor” due to voice users. When the voice traffic increases it was found that more voice calls are blocked, while the performance for the 2 Mb/s data user remain optimal.
|
198feca7a70995985a5cc7f203dbedb2
|
25.867
|
7 Operation & Maintenance
|
In order to identify any possible impact of a communication interface between WDS and other network elements R3-011933 [Ref. 2] and R5-010481 [Ref. 3] were discussed within RAN 3 and SA5 respectively.
Either working group said that no impact was found on existing specs because of WDS, and it appeared that existing specifications don’t prevent possible network configuration including WDS. Detail outcomes are included in following sub-sections.
7.1 WDS O&M interface
The O&M interface for WDS may be required to provide operational status and alarm information to each Network Operator having access to the system, under a network-specific set of parameters, i.e. including:
• General information on common infrastructure available to all networks
• Network specific information (i.e. any interface specific failure alarms)
Transport bearer for O&M implementation may be compliant with TS 25.442, and that in order to re-use existing transport facilities it would share the same physical and data layer of Iub, as Implementation Specific O&M.
7.2 WDS O&M architecture
O&M of WDS may be included as part of "O&M functions for co-located equipment", as its architecture could fulfil the requirement. So-called Interface-N is part of the standard (TS32.101, TS32.102) as the interface towards the systems at the network management level. This means that this interface con be offered either from an element manager or directly from the network elements. Special integration reference points "IRP's" are defined and standardised with different solutions sets (CMIP or CORBA) for alarms and configuration.
One problem with the WDS may be related with independent requirement from network operators.
At least two ways to solve the problem may be identified:
• The WDS system complies with the IRP concept, or it offers e.g. an alarm IRP for fault management; or
• The UMTS Telecom Management Architecture just offers a transparent connection to vendor specific management system for WDS.
7.3 WDS O&M activity plan
Further work is required in order to address all practical issues that may arise from system integration activities. This work will require co-ordination between RAN4, RAN3, and SA5
|
198feca7a70995985a5cc7f203dbedb2
|
25.867
|
8 Location Services (LCS)
|
In order to assess any impact of WDS on location services, the co-existence between WDS and location services (LCS) is discussed in this section. Three methods for location services are currently specified in TS 25.305 – Stage 2 Functional Specification of Location Services in UTRAN. These are OTDOA, Cell ID based positioning and Network Assisted GPS.
|
198feca7a70995985a5cc7f203dbedb2
|
25.867
|
8.1 OTDOA/IPDL
|
The OTDOA/IPDL methods are based on the measurements of the UTRA pilot signal (CPICH) made by the UE and the Location Measurement Unit (LMU). The position of the UE is estimated by using the observed time difference of arrival from three or more base stations.
As measurements are made by the UE who then reports them to the Position Calculation Function (PCF) in the serving RNC, any delays between the remote RF antenna and the serving BS which may be introduced by the WDS are not part of the LCS calculation. In this case the PCF must be aware of the geographical layout of the UTRAN transmitters as configured including WDS.
8.2 Cell ID Method
In the cell ID based method the location of a UE is estimated with the knowledge of its serving BS. The information about the serving BS and cell may be obtained by paging, location area update, cell update, URA update or routing area update.
The result of WDS deployment is that the cells have the potential to become smaller thereby giving greater accuracy compared to a larger cell.
|
198feca7a70995985a5cc7f203dbedb2
|
25.867
|
8.3 Network Assisted GPS
|
These methods make use of UE, which are equipped with radio receivers capable of receiving signals from the Global Positioning System (GPS). Therefore there are no implications to a WDS enhanced network.
|
198feca7a70995985a5cc7f203dbedb2
|
25.867
|
8.4 Summary of WDS impact on LCS
|
From the above discussion it is clear that no impact on LCS is envisaged due to inclusion of WDS
The system calculations required in order to accommodate the provision of LCS information to the network rely primarily on the UE or high level network systems specifically dedicated to LCS.
The only provision for inclusion of WDS will be the requirement that the RNC is aware of the base station architecture including the length of transmission delay in order to make accurate positional calculations.
|
198feca7a70995985a5cc7f203dbedb2
|
25.867
|
9 WDS Positioning on Existing 3GPP TS and WI
|
The present structure of 3GPP UTRAN FDD specifications includes BS (TS 25.104 [ref.1] / TS 25.141 [ref.2]) and Repeaters (TS 25.106 [ref.3]/ TS 25.143 [ref.4]).
TS25.104 relates to Macro BS and its performance. Ongoing work on Base Station Classification WI (TR25.951).
TS25.106 relates to RF Repeater and its performance. The following discussion identifies WDS positioning situation in 3GPP FDD UTRAN TS frame.
|
198feca7a70995985a5cc7f203dbedb2
|
25.867
|
9.1 WDS positioning discussion
|
Following points highlight specific technical positioning for WDS, starting from simulations results.
1. WDS are physically connected to BS according to capacity and coverage planning requirements. They are NOT used to complement radio coverage of a BS (so-called simulcasting), and therefore provide consistent and reliable performance as integral part of the access network, including minimisation of uncertainties in UE location;
2. Because of the tight interface to BS, WDS have low or moderate RF gain. Therefore they don’t need complex filtering techniques to provide control of in-band and out-of-band spurious emissions; additionally, WDS allow for controlled and reliable performance in both single- and multi-vendor scenarios, leading to ease of planning; similarly, a reliable alarm and management interface may be provided as discussed;
3. Standard technologies provide WDS instantaneous bandwidth capability to cope with UMTS UTRA FDD full band application, including the various regional requirements;
4. WDS allows BS and RNC to be co-located at centralised equipment locations, where upgrades and implementations can be effected with no requirement to visit remote sites.
The above listed items show WDS ability to supplement and enhance FDD BS capability, and their substantial technical and deployment difference from repeaters. WDS are meant as radio interface remotisers for one or multiple dedicated BS.
|
198feca7a70995985a5cc7f203dbedb2
|
25.867
|
9.2 Potential Impact of WDS Standardisation
|
The Feasibility Study has highlighted the potential impact of WDS standardisation based on existing BS specifications TS25.104/TS25.141, with specific reference to the interface point between BS and WDS, where a more stringent performance than that of compliant BS may be required in order to guarantee full compliance to the standard for the new chain [BS + WDS].
Since Companies did not agree to changing existing specifications because of possible impact in future BS layout, no agreement has been reached at RAN WG4 about such an interface.
The existing and ongoing status of the WI on UTRAN FDD Base Station Classification (TR25.951) offers instead benefits for WDS in certain deployment scenarios and can be related to it.
|
198feca7a70995985a5cc7f203dbedb2
|
25.867
|
10 Conclusions and Way Forward
|
The Feasibility Study has shown how WDS performance may impact on a 25.104 compliant generic BS, on a limited number of basically important parameters and, more in general, in the network configuration.
A new set of compliance parameters should be investigated as a consequence of BS classification and further definition of deployment scenarios.
Further work is required to verify the recommended margin consistency for the remaining uplink parameters (e.g. Noise Figure, Blocking, and Intermodulation) and downlink parameters (e.g. Modulation Accuracy, Frequency Stability and Accuracy, Output Power Stability and Accuracy) for all scenarios, particularly in the multi-carrier case.
Since it was not yet possible to agree on any different requirements for BS specifications, and because of the specific interest for using WDS for small cell applications, it may be recommended to relate any further related work on WDS to the definition of BS classes for given deployment scenarios, and for those RF parameters that may be part of WDS technical nature. The way WDS may be included in 3GPP specs is not clear yet and needs further co-ordination with other ongoing work in related areas (e.g. BS classification and Repeaters).
Annex <A>: History of the proposal
RAN 4 Meeting #17, Gothenburg, Sweden (21-25 May 2001)
Document R4- 010559 Technical justification and overall advantages of WDS
Discussion document explained the concept and the benefits of a WDS. A hardware description and RF performance attributes were discussed in relation to the current TS25.104 specification. It was agreed to proceed with a feasibility study.
RAN Plenary Meeting #12, Stockholm, Sweden (12-15 June 2001)
Document RP-010488 Study Item description sheet for feasibility study on UTRA WDS
Document detailed the justification for the system and set out the criteria which must be satisfied in order to proceed. This included addressing RF performance, end to end system performance and consideration of location service and O&M aspects. Study Item status was given.
RAN 4 Meeting #18, Berlin, Germany (9-13 July 2001)
Document R4-010935 WDS Study Item Status Update
Document presented for information and to raise discussion items to be addressed in final study phase TR.
Concerns were raised about impact on system performance due to inclusion of WDS. Difficulties were voiced on setting new requirements on TS25.104 for a low-level interface (LLI) between the BS and the WDS.
Therefore clarifications on the concept were required.
RAN 4 Meeting #19, Edinburgh, Scotland (3-7 September 2001)
Document R4-011045 WDS Study Item Report
Feasibility Study results presented for decision which covered the following subjects:
1. End to end system performance improvements shown through major simulation work.
2. RF up-link and downlink parameters for LLI, WDS and compliance to TS25.104 at antenna port.
3. Address all questions raised at previous RAN 4 meetings with detailed explanations of LLI concept, system degradation, LCS and O&M impact.
It was noted by a number of delegates that there were no doubts of the benefits of WDS, specifically in order to provide the ability to share resources in indoor environments.
Further concerns were raised by some delegates over the understanding of LLI, specifically on how it may physically interface with variable BS configurations and about its technical feasibility against existing TS 25.104.
Due to recognised benefits of WDS, it was recommended that the study item phase be continued in order to close out the points raised.
RAN plenary meeting #13, Beijing, China (18-21 September 2001)
Document RP-010638 Status Report for information
Completion date is expected at RP#14 with formal TR. It was commented that the included report was not a formal TR and that no agreement had yet been reached on it in WG4.
RAN 4 Meeting #20, East Brunswick, NJ, USA (12-16 November 2001)
Document R4-011516 Submission of present TR 25.867 v.0.1.0
Change history
Change history
Date
TSG #
TSG Doc.
CR
Rev
Subject/Comment
Old
New
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
1 Scope
|
The present document specifies an initial set of Parlay X Web Services. For each selected Web Service, this document describes the motivation for its inclusion, the commercial and technical rationale, and an illustrative usage scenario(s). This document also specifies the message(s) exchanged during invocations of each Web Service, by defining the semantics in English and the syntax using W3C WSDL.
The OSA APIs are designed to enable creation of telephony applications as well as to "telecom-enable" IT applications. IT developers, who develop and deploy applications outside the traditional telecommunications network space and business model, are viewed as crucial for creating a dramatic whole-market growth in next generation applications, services and networks.
The Parlay X Web Services are intended to stimulate the development of next generation network applications by developers in the IT community who are not necessarily experts in telephony or telecommunications. The selection of Web Services should be driven by commercial utility and not necessarily by technical elegance. The goal is to define a set of powerful yet simple, highly abstracted, imaginative, telecommunications capabilities that developers in the IT community can both quickly comprehend and use to generate new, innovative applications.
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
2 References
|
The following documents contain provisions which, through reference in this text, constitute provisions of the present document.
• References are either specific (identified by date of publication, edition number, version number, etc.) or non‑specific.
• For a specific reference, subsequent revisions do not apply.
• For a non-specific reference, the latest version applies. In the case of a reference to a 3GPP document (including a GSM document), a non-specific reference implicitly refers to the latest version of that document in the same Release as the present document.
[1] 3GPP TR 21.905: "Vocabulary for 3GPP Specifications".
[2] 3GPP TS 22.101: "Service aspects; Service principles".
[3] 3GPP TS 23.040: "Technical realization of Short Message Service (SMS)".
[4] RFC 2396: "Uniform Resource Identifiers (URI): Generic Syntax".
[5] RFC 2732: "Format for Literal IPv6 Addresses in URL's".
[6] RFC 2806: "URLs for Telephone Calls".
[7] RFC 3261: "SIP: Session Initiation Protocol".
[8] RFC 2848: "The PINT Service Protocol: Extensions to SIP and SDP for IP Access to Telephone Call Services".
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
3 Definitions and abbreviations
| |
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
3.1 Definitions
|
For the purposes of the present document, the terms and definitions given in 3GPP TS 22.101 [2] and the following apply.
(Parlay X) Application: unless otherwise specified, the document will be using the term (Parlay X) application to refer to software that invokes or can invoke a Parlay X Web Service.
Parlay X Gateway: used to describe the implementation of a set of Parlay X Web Services. In telecommunications parlance an implementation of a Parlay X Web Service on a Parlay X Gateway would also be referred to as a service.
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
3.2 Abbreviations
|
For the purposes of the present document, the abbreviations given in 3GPP TR 21.905 [1] and the following apply.
A/IN (Advanced) Intelligent Network
AAA Authorization, Authentication, and Accounting
AM Account Management
API Application Programming Interface
APP Application
CBC Content Based Charging
CC Call Control
DIME Direct Internet Message Encapsulation
EMS Enhanced Messaging Service
FW (OSA/Parlay) Framework
GIF Graphics Interchange Format
GPRS General Packet Radio System
IM Instant Messaging
IP Internet Protocol
ICQ ???
IT Information Technology
IVR Interactive Voice Response
JAIN Integrated Network APIs for the JavaTM platform
JCP JavaTM Community ProcessSM
JPay Payment API for the JavaTM platform
MIME Multipurpose Internet Mail Extensions
MM7 Communication protocol between MMS Relay/Server and MMS Application Server
MMS Multimedia Message Service
MMS-C Multimedia Message Service Center
MPS Mobile Positioning System
MS Mobile Station Why not UE User Equipment ???? - see 3GPP TR 21.905 [1]
MSC Mobile Switching Center
MSISDN Mobile Station ISDN Number
OASIS Organization for the Advancement of Structured Information Standards
PIN Personal Identification Number
PINT PSTN and Internet inter-networking
PSTN Public Switched Telephone Network
SAML Security Assertion Markup Language: i.e. an XML-based security standard for exchanging authentication and authorization information, developed by SSTC)
SCF Service Capability Feature
SCS Service Capability Server
SIP Session Initiation Protocol
SLA Service Level Agreement
SMS Short Message Service
SMS-C Short Message Service Center
SOAP Simple Object Access Protocol
SSTC Security Services Technical Committee (of OASIS)
UCP Universal Computer Protocol
URI Uniform Resource Identifier
VASP Virtual Application Service Provider
W3C World Wide Web Consortium
WAP Wireless Application Protocol
WG Working Group
WGS 84 World Geodetic System 1984
WS Web Service
WSDL Web Service Definition Language
WS-I Web Services-Interoperability Organization
XML Extensible Markup Language
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
4 Parlay X Web Services
| |
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
4.1 Selection Criteria
|
Each Parlay X Web Service should be abstracted from the set of telecommunications capabilities exposed by the Parlay APIs, but may also expose related capabilities that are not currently supported in the Parlay APIs where there are compelling reasons. These tiered levels of abstraction, and the Parlay – Parlay X relationship, are illustrated in
Figure 1.
Figure 1: Parlay X Web Services, Parlay X APIs and Parlay APIs
The selection criteria for the Parlay X Web Services are as follows:
• The capabilities offered by a Parlay X Web Service may be either homogeneous (e.g. call control only) or heterogeneous (e.g. terminal location and user status).
• The interaction between an application incorporating a Parlay X Web Service and the server implementing the Parlay X Web Service will be done with an XML-based message exchange. The message exchange should follow the synchronous request/response model and be initiated by the application; the 'response' from the Parlay X Web Service is optional. However asynchronous messages from the Parlay X Web Service implementation (on a Parlay X Gateway) to the application may be defined where there are compelling reasons; e.g. to implement a notification type web service. In the latter case, the message exchange would invoke an application web service using a similar, synchronous request/response model.
• Parlay X Web Service invocations should not be correlated and the Web Service itself should be stateless from the perspective of the application, unless there are compelling reasons. In particular, in the case of asynchronous notifications from a Parlay X Web Service implementation (on a Parlay X Gateway) to an application, NO application-initiated invocations to provision (or de-provision) notification-related criteria in the Parlay X Web Service should be implemented.
• Parlay X Web Services follow simple application semantics, allowing the developer to focus on access to the telecom capability using common Web Services programming techniques.
• Parlay X Web Services are not network equipment specific, and not network specific where a capability is relevant to more than one type of network.
• Parlay X Web Services should be based on the reference Web Service technology, as it is defined in the IT world and according to the Parlay Web Services WG recommendations; more specifically, at the moment, WSDL is the chosen standard to invoke and describe Parlay X Web Services.
• The Parlay X APIs should be extendible; integration of third party provided interfaces must be supported using proven, reliable, and standard Web Service technology.
• Parlay X Web Services are application interfaces and do not provide an implementation of AAA (Authorization, Authentication, and Accounting), service level agreements or other environment-specific capabilities. Rather, they shall rely on proven and reliable solutions provided by the Web Services infrastructure.
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
4.2 Implementation Considerations
| |
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
4.2.1 Versioning
|
The namespace will contain a version number as a suffix for the service name. The suffix will be a separate path element consisting of: the letter 'v' followed by a major version number followed by an underscore and a minor version number.
• The major version number will reflect the version of Parlay X for the last change to the API.
• The minor version number will reflect maintenance of the API between Parlay X versions.
EXAMPLE: www.csapi.org/wsdl/parlayx/account_management/v1_0 represents the initial public version of the Parlay X Account Management Web Service.
The rationale for this version number scheme is as follows:
• Prefixing the path element with "v" and using an underscore minimizes the possibility of tool issues. Using namespace elements that are only digits (or that contain characters other than letters, digits and underscores) may result in issues with different tools - e.g. period is a package delimiter
• Adding the version path element after the API element, instead of after the "parlayx" element, means that as Parlay X changes, that APIs that do not change will not require changes to running services since their namespaces will not change
• Using this convention eliminates parsing and related issues with two digit versions, leading zeros, etc.
• This convention can also be applied to other Parlay X namespaces such as Common Data.
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
4.3 Optional Parameters
|
Some parameters are defined as OPTIONAL. Within a message signature, the XML schema type definition for an optional parameter may use the nillable attribute to allow the actual value of the parameter to be "NULL" (or "NIL"). Since this approach is dependant upon the industry adoption of WS-I's Basic Profile 1.0, which is currently not widely implemented, this version of the Parlay X Web Services specification does not follow this approach. As a temporary measure this specification explicitly defines "NULL" values for parameters tagged OPTIONAL such that, if used, the actual value of the parameter must be considered "NULL".
The following "NULL" values are defined for each OPTIONAL parameter data type:
• Type String: the empty string ("").
• Type DateTime: "0001-01-01T00:00:00Z".
• Type Integer: "-1".
• Type EndUserIdentifier (which encapsulates a URI): "null://null".
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
4.4 Document Structure
|
The present document has the following clauses:
4) Parlay X Web Services
5) Common Data Definitions
6) Third Party Call
7) Network-Initiated Third Party Call
8) SMS
9) Multimedia Message
10) Payment
11) Account Management
12) User Status
13) Terminal Location
Apart from this clause and clause 5, each of the remaining clauses specifies a Parlay X Web Service with the following structure:
• Overview, describing the Web Service, the underlying commercial and/or technical rationale, its relationship to other specifications, and illustrative usage scenario(s).
• A semantic specification of the message-based Parlay X API(s) that constitute the Web Service.
• A definition of the Web-Service-specific data types and exceptions.
• Web Service Syntax, referencing two types of WSDL files for this release of the Parlay X APIs:
• A modular set of WSDL files that provide an 'rpc/literal' binding and follows the current draft provided by the WS-I Basic Profile. This set of files may be used by tools that support the features included in the Basic Profile definition.
• A second set of monolithic WSDL files that provide an 'rpc/encoded' binding and use SOAP encoded arrays. This allows developers to use tools that do not yet support the features included in the Basic Profile definition. It is expected that tools will be updated over time, and that developers will migrate to the first set of files, to be compliant with the WS-I Basic Profile.
This document structure, one clause for each Parlay X Web Service, facilitates future releases of the Parlay X specification. It minimizes the scope of editorial work required to either introduce a new Parlay X Web Service, which is accomplished by adding a new document clause, or to update an existing Parlay X Web Service, which is achieved by editing a single, existing document clause.
In addition to the Parlay X Web Service-specific clauses, the present document (in clause 5) provides a listing of data definitions (including exceptions) that are common across multiple Parlay X Web Services. As more Web Services are defined in the future, the number of common data definitions may increase. Thus clause 5 has the following structure:
• Record of Changes, providing a detailed record of any additions, deletions, modifications and other changes that have been applied to the data definitions since its previous public release.
• An English language definition of the common data types and exceptions.
• Common Data Definitions Syntax, referencing two types of WSDL files for this release of the Parlay X APIs.
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
5 Common Data Definitions
| |
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
5.1 Common Data Type Definitions
|
Where possible standard XML Schema data types are used, as defined in http://www.w3.org/TR/xmlschema-2/#built-in-datatypes.
Other data types that are common to multiple Parlay X Web Services are defined in the following subclauses.
5.1.1 EndUserIdentifier
The EndUserIdentifier data type is specified as a URI: [scheme]:[schemeSpecificPart] (RFC 2396 [4], amended by RFC 2732 [5]). Example schemes are tel (RFC 2806 [6]) and sip (RFC 3261 [7]).
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
5.1.2 ArrayOfEndUserIdentifier
|
A collection of elements where each element is of data type EndUserIdentifier.
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
5.1.3 ArrayOfURI
|
A collection of elements where each element is of data type URI.
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
5.2 Common Exception Definitions
|
All of these exceptions are common to multiple Parlay X Web Services. Each exception is assigned an eight character identifier, where:
• The first 3 characters "GEN" identify the exception as generic: i.e. common to multiple Parlay X services. The "GEN" string shall not be assigned to any Parlay X Web Service-specific exception.
• The next 4 digits "1xxx" uniquely identifies the exception within the set of common exceptions. The "1xxx" string may be re-used by any Parlay X Web Service-specific exception defined in this specification.
• The last character identifies the severity of the exception condition, as follows:
• "F": fatal error, typically indicating an infrastructure problem; the operation triggering the exception should not be retried
• "E": error, typically indicating an application or user error; the operation triggering the exception has not completed and may be retried
• "W": warning, typically indicating that an operation has completed, but there are cautions or other caveats.
The common exceptions are as follows:
UNIQUE ID
TEXT STRING
MEANING
GEN1000E
UnknownEndUserException
This fault occurs if the end user identification that is passed is unknown.
GEN1001E
InvalidArgumentException
This fault occurs if an argument passed is semantically incorrect or when the parameter does not conform to the limits specified in the Parlay X specification: e.g. when passing the end user identification: "tel:www.parlay.org".
GEN1002F
ServiceException
This fault is caused by generic platform or network errors.
GEN1003E
PolicyException
This fault is caused by a violation of a policy of the Parlay X Web Service: e.g., when parameter values are used that are outside the scope of the service level agreement.
GEN1004E
ApplicationException
This fault is caused by a generic error in an application web service when processing a message invocation from a Parlay X Web Service. The Parlay X Web Service can log this information and possibly raise an alarm when the number of exceptions reaches a pre-defined threshold.
GEN1005W
MessageTooLongException
This fault is caused if a message to be sent exceeds the maximum length supported by the Web Service; e.g. the message may be too long for a destination terminal device.
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
5.3 Common Data Definitions Syntax – WSDL
|
The rpc/literal files include two common files
• parlayx_common_types.xsd
• parlayx_common_faults.wsdl
The rpc/encoded files contain these definitions within each service file.
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
6 Third Party Call
| |
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
6.1 Overview
| |
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
6.1.1 Description
|
Currently, in order to perform a third party call in telecommunication networks we have to write applications using specific protocols to access Call Control functions provided by network elements (specifically operations to initiate a call from applications). This approach requires a high degree of network expertise. We can also use the OSA gateway approach, invoking standard interfaces to gain access to call control capabilities, but these interfaces are usually perceived to be quite complex by application IT developers. Developers must have advanced telecommunication skills to use Call Control OSA interfaces.
In this subclause we describe a Parlay X Web Service, Third Party Call, for creating and managing a call initiated by an application (third party call). The overall scope of this Web Service is to provide functions to application developers to create a call in a simple way. Using the Third Party Call Web Service, application developers can invoke call handling functions without detailed telecommunication knowledge.
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
6.1.2 Commercial & Technical Rationale
|
The basic commercial rationale for developing the Third Party Call Web Service is:
• to increase the use of Call Control capabilities in software applications
• to empower traditional IT developers to produce large numbers of such applications
• to lower the development cost and time for such applications.
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
6.1.3 Relationship to Similar or Supplanted Specifications
|
In the PSTN/Internet Interworking (PINT) working group a "request to call" scenario has been defined (RFC 2848 [8]). A request is sent to an IP host that cause a phone call to be made, connecting party A to some remote party B.
The PINT approach is not API-based but instead it proposes an extension to SIP to implement the scenarios identified. The Third Party Call Web Service proposed here while addressing similar scenarios aims at providing a high-level Web Services interface to invoke the service. It does not aim at defining a concrete architecture implementing the functionality. Therefore the two specifications are at different levels of abstraction.
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
6.1.4 Scenarios
|
shows an scenario using the Third Party Call Web Service to handle third party call functions. The application invokes a web service to retrieve stock quotes and a Parlay X Interface to initiate a third party call between a broker and his client.
In the scenario, whenever a particular stock quote reaches a threshold value (1) and (2), the client application invokes a third party call between one or more brokers and their corresponding customers to decide actions to be taken. After invocation (3) by the application, the Third Party Call Web Service invokes a Parlay API method (4) using the Parlay/OSA SCS-CC (Call control) interface. This SCS handles the invocation and sends a message (5) to an MSC to set-up a call between user A and user B.
In an alternative scenario, the Parlay API interaction involving steps (4) and (5) could be replaced with a direct interaction between the Third Party Call Web Service and the Mobile network.
Figure 2: Third Party Call Scenario
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
6.2 Call API
|
This subclause describes an initial set of capabilities in terms of message invocations, parameters and data types. The message-based invocations are:
• makeACall
• getCallInformation
• endCall
• cancelCallRequest
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
6.2.1 Attempt Immediate Call Set-Up Between Two Addresses
|
a) makeACall(EndUserIdentifier callingParty, EndUserIdentifier calledParty, String charging, out String callIdentifier)
b) Behaviour:
The invocation of makeACall requests to set-up a voice call between two addresses, callingParty and calledParty, provided that the invoking application is allowed to connect them. Optionally the application can also indicate the charging arrangements (charging), i.e. the name of an operator-specific charging plan that defines who to charge for the call and how much.
By invoking this operation the application requires to monitor the status of the requested call. The returned parameter, callIdentifier, can be used to identify the call. In order to receive the information on call status the application has to explicitly invoke getCallInformation.
c) Parameters:
NAME
TYPE
DESCRIPTION
callingParty
EndUserIdentifier
It contains the address of the first user involved in the call
calledParty
EndUserIdentifier
It contains the address of the second user involved in the call
charging
String
OPTIONAL. If present, represents the name of an operator-specific charging plan that defines who to charge for the call and how much. If the named charge plan does not exist, the InvalidArgumentException is thrown. If no charge plan is specified, charging occurs in accordance with an operator-specific charging policy.
callIdentifier
String
OUTPUT. It identifies a specific call request
d) Exceptions:
UnknownEndUserException
InvalidArgumentException
ServiceException
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
6.2.2 Get Current Status of a Call
|
a) getCallInformation(String callIdentifier, out CallInformationType callInformation)
b) Behaviour:
The invocation of getCallInformation retrieves the current status, callInformation, of the call identified by callIdentifier. This method can be invoked multiple times by the application even if the call has already ended. However, after the call has ended, status information will be available only for a limited period of time that should be specified in an off-line configuration step.
c) Parameters:
NAME
TYPE
DESCRIPTION
callIdentifier
String
It identifies a specific call request
callInformation
CallInformationType
OUTPUT. It identifies the status of the call
d) Exceptions:
UnknownCallIdentifierException
ServiceException
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
6.2.3 End a Call
|
a) endCall(String callIdentifier)
b) Behaviour:
The invocation of endCall terminates the call identified by callIdentifier. If the call is still in the initial state this method has the same effect as the cancelCallRequest method.
c) Parameters:
NAME
TYPE
DESCRIPTION
callIdentifier
String
It identifies a specific call request
d) Exceptions:
CallTerminatedException
UnknownCallIdentifierException
ServiceException
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
6.2.4 Cancel a Call Request
|
a) cancelCallRequest(String callIdentifier)
b) Behaviour:
The invocation of cancelCallRequest cancels the previously requested call identified by callIdentifier. Note that this method differs from the endCall method since it only attempts to prevent the call from starting but it does not have any effect if the call has already started.
c) Parameters:
NAME
TYPE
DESCRIPTION
callIdentifier
String
It identifies a specific call request
d) Exceptions:
CallConnectedException
UnknownCallIdentifierException
ServiceException
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
6.3 Web Service Data Definitions
| |
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
6.3.1 Data Types
|
In addition to the Common Data Types defined in clause 5, the following Data Types are specific to this Web Service.
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
6.3.1.1 CallInformationType
|
The CallInformationType data type is a structure containing the following parameters:
NAME
TYPE
DESCRIPTION
callStatus
CallStatus
It indicates the current status of the call (see possible values below)
startTime
DateTime
When applicable (callStatus <> CallInitial), it indicates the time of the beginning of the call
duration
Integer
When applicable (callStatus = CallTerminated), it indicates the duration of the call expressed in seconds
terminationCause
CallTerminationCause
When applicable (callStatus = CallTerminated), it indicates the cause of the termination of the call (see possible values below)
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
6.3.1.2 CallStatus
|
The CallStatus data type is an enumeration with the following values:
VALUE
DESCRIPTION
CallInitial
The call is being established
CallConnected
The call is active
CallTerminated
The call was terminated
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
6.3.1.3 CallTerminationCause
|
The CallTerminationCause data type is an enumeration with the following values:
VALUE
DESCRIPTION
CallingPartyNoAnswer
Calling Party did not answer
CalledPartyNoAnswer
Called Party did not answer
CallingPartyBusy
Calling Party was busy
CalledPartyBusy
Called Party was busy
CallingPartyNotReachable
Calling Party was not reachable
CalledPartyNotReachable
Called Party was not reachable
CallHangUp
The call was terminated by either party hanging up
CallAborted
The call was aborted (any other termination cause)
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
6.3.2 Exceptions
|
In addition to the Common Exceptions defined in clause 5.2, there are exceptions specific to this Web Service. Similar to the Common Exceptions, each Web Service-specific exception is assigned an eight-character identifier. This identifier is interpreted as described in clause 5.2, except that the first 3 characters uniquely identify this Web Service.
The following exceptions are specific to this Web Service:
UNIQUE ID
TEXT STRING
MEANING
3PC1000W
CallConnectedException
The call was already active
3PC1001W
CallTerminatedException
The call is already terminated
3PC1002E
UnknownCallIdentifierException
The callIdentifier supplied does not relate to any known call request or has expired.
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
6.4 Web Service Syntax – WSDL
|
The W3C WSDL representation of this API is contained in a set of files which accompany the present document (see Annex A).
The rpc/literal files are
• parlayx_third_party_calling_types.xsd
• parlayx_third_party_calling_service_port.wsdl
• parlayx_third_party_calling_service.wsdl
The rpc/encoded file is
• parlayx_third_calling_party_service.wsdl.
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
7 Network-Initiated Third Party Call
| |
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
7.1 Overview
| |
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
7.1.1 Description
|
Currently, in order to determine the handling of a subscriber initiated call in telecommunication networks we have to write applications using specific protocols to access Call Control functions provided by network elements. This approach requires a high degree of network expertise. We can also use the OSA gateway approach, invoking standard interfaces to gain access to call control capabilities, but these interfaces are usually perceived to be quite complex by application IT developers. Developers must have advanced telecommunication skills to use Call Control OSA interfaces.
In this subclause we will describe a Parlay X Web Service, Network-Initiated Third Party Call, for handling calls initiated by a subscriber in the network. A (third party) application determines how the call should be treated. The overall scope of this Web Service is to provide simple functions to application developers to determine how a call should be treated. Using the Network-Initiated Third Party Call Web Service, application developers can perform simple handling of network-initiated calls without specific Telco knowledge.
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
7.1.2 Commercial & Technical Rationale
|
The basic commercial rationale for developing the Network-Initiated Third Party Call Web Service is:
• to increase the use of Call Control capabilities in software applications
• to empower traditional IT developers to produce large numbers of such applications
• to lower the development cost and time for such applications.
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
7.1.3 Relationship to Similar or Supplanted Specifications
|
All the capabilities of the Network-Initiated Third Party Call Web Service (and more) can also be achieved with the Parlay/OSA generic call control or multiparty call control services. The Network-Initiated Third Party Call Web Service can be seen as a very limited subset of the network initiated call control functionality present in Parlay/OSA. This has the advantage that the application needs less telecom knowledge. The disadvantage is that the control over the call is much reduced. Basically, a Parlay X application can only choose to release, continue or re-route the call. It does not have control over the specific parameters used in the call (e.g., on the presentation indicators of the addresses), nor can the application control the call over a longer period of time. Furthermore, it is not likely that the robustness and performance requirements of Parlay/OSA services will be matched by the Network-Initiated Third Party Call Web Service.
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
7.1.4 Scenarios
|
This subclause gives some possible scenarios using the Network-Initiated Third Party Call Web Service to handle network-initiated calls.
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
7.1.4.1 Incoming call handling
|
A subscriber receives a call while he is logged-on to the Internet. Since this occupies his telephone connection, he is regarded as busy by the network. The subscriber has an application that is invoked when somebody tries to call him while he is busy. The application provides the subscriber with a list of choices on how to handle the call (e.g., route the call to voicemail, redirect the call to a secretary, reject the call). Based on the response of the subscriber the call is handled in the network.
Alternatively, the call be re-routed or released depending on the preferences of the subscriber and some context information (e.g., based on the status or location of the subscriber).
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
7.1.4.2 Service numbers
|
An application is triggered whenever a certain service number is dialled. This number is used to connect the caller to one of the maintenance personnel. The application redirects the call to the appropriate maintenance person based on, e.g., calling party number, time, location and availability of the maintenance personnel.
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
7.2 Call API
|
This subclause describes an initial set of capabilities in terms of message invocations, parameters and data types. The message-based invocations are:
• handleBusy
• handleNotReachable
• handleNoAnswer
• handleCalledNumber
• handleOffHook
These messages are initiated by the Network-Initiated Third Party Call Web Service (running in a Parlay X Gateway) and invoke an application web service(s), as a result of activity in the network. The result of the invocation is used as an indication on how the call should be handled in the network.
Note that because the results of the invocations of the application web service(s) determine call handling in the network, the names of the methods are prefixed with 'handle', rather than 'notify'. The prefix 'notify' would imply a more asynchronous behaviour, whereas 'handle' shows the synchronous nature of these invocations.
The type of events (busy, answer etc.) and related numbers, for which the application web service(s) should be invoked, should be determined by the operator in an off-line process.
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
7.2.1 Request Application Handling of a 'Busy' Condition
|
a) handleBusy(EndUserIdentifier callingParty, EndUserIdentifier calledParty, out Action action)
b) Behaviour:
The invocation of handleBusy requests the application to inform the gateway how to handle the call between two addresses, the callingParty and the calledParty, where the calledParty is busy when the call is received. The application returns the action, which directs the gateway to perform one of the following actions:
• "Continue", resulting in normal handling of the busy event in the network, e.g. playing of a busy tone to the callingParty
• "EndCall", resulting in the call being terminated; the exact tone or announcement that will be played to the callingParty is operator-specific
• "Route", resulting in the call being re-routed to a calledParty specified by the application.
Optionally, in the action parameter, the application can also indicate the charging arrangements, i.e. the name of an operator-specific charging plan that defines who to charge for the call and how much.
c) Parameters:
NAME
TYPE
DESCRIPTION
callingParty
EndUserIdentifier
It contains the address of the caller.
calledParty
EndUserIdentifier
It contains the address of the called party. This party is busy.
action
Action
OUTPUT. It indicates the action to be performed by the gateway.
d) Exceptions:
ApplicationException
UnknownEndUserException
InvalidArgumentException
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
7.2.2 Request Application Handling of a 'Not Reachable' Condition
|
a) handleNotReachable(EndUserIdentifier callingParty, EndUserIdentifier calledParty, out Action action)
b) Behaviour:
The invocation of handleNotReachable requests the application to inform the gateway how to handle the call between two addresses, the callingParty and the calledParty, where the calledParty is not reachable when the call is received. The application returns the action, which directs the gateway to perform one of the following actions:
• "Continue", resulting in normal handling of the 'not reachable' event in the network, e.g. playing of a busy tone to the callingParty
• "EndCall", resulting in the call being terminated; the exact tone or announcement that will be played to the callingParty is operator-specific
• "Route", resulting in the call being re-routed to a calledParty specified by the application.
Optionally, in the action parameter, the application can also indicate the charging arrangements, i.e. the name of an operator-specific charging plan that defines who to charge for the call and how much.
c) Parameters:
NAME
TYPE
DESCRIPTION
callingParty
EndUserIdentifier
It contains the address of the caller.
calledParty
EndUserIdentifier
It contains the address of the called party. This party is not reachable.
action
Action
OUTPUT. It indicates the action to be performed by the gateway.
d) Exceptions:
ApplicationException
UnknownEndUserException
InvalidArgumentException
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
7.2.3 Request Application Handling of a 'No Answer' Condition
|
a) handleNoAnswer(EndUserIdentifier callingParty, EndUserIdentifier calledParty, out Action action)
b) Behaviour:
The invocation of handleNoAnswer requests the application to inform the gateway how to handle the call between two addresses, the callingParty and the calledParty, where the calledParty does not answer the received call. The application returns the action, which directs the gateway to perform one of the following actions:
• "Continue", resulting in normal handling of the 'no answer' event in the network, e.g. playing of a busy tone to the callingParty
• "EndCall", resulting in the call being terminated; the exact tone or announcement that will be played to the callingParty is operator-specific
• "Route", resulting in the call being re-routed to a calledParty specified by the application.
Optionally, in the action parameter, the application can also indicate the charging arrangements, i.e. the name of an operator-specific charging plan that defines who to charge for the call and how much.
c) Parameters:
NAME
TYPE
DESCRIPTION
callingParty
EndUserIdentifier
It contains the address of the caller.
calledParty
EndUserIdentifier
It contains the address of the called party. This party does not answer the call.
action
Action
OUTPUT. It indicates the action to be performed by the gateway.
d) Exceptions:
ApplicationException
UnknownEndUserException
InvalidArgumentException
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
7.2.4 Request Application Handling of a 'Called Number' Condition
|
a) handleCalledNumber(EndUserIdentifier callingParty, EndUserIdentifier calledParty, out Action action)
b) Behaviour:
The invocation of handleCalledNumber requests the application to inform the gateway how to handle the call between two addresses, the callingParty and the calledParty. The method is invoked when the callingParty tries to call the calledParty, but before the network routes the call to the calledParty. For example, the calledParty does not have to refer to a real end user, i.e., it could be a service number. The application returns the action, which directs the gateway to perform one of the following actions:
• "Continue", resulting in normal handling in the network, i.e. the call will be routed to the calledParty number, as originally dialled
• "EndCall", resulting in the call being terminated; the exact tone or announcement that will be played to the callingParty is operator-specific
• "Route", resulting in the call being re-routed to a calledParty specified by the application.
Optionally, in the action parameter, the application can also indicate the charging arrangements, i.e. the name of an operator-specific charging plan that defines who to charge for the call and how much.
c) Parameters:
NAME
TYPE
DESCRIPTION
callingParty
EndUserIdentifier
It contains the address of the caller.
calledParty
EndUserIdentifier
It contains the address of the called party.
action
Action
OUTPUT. It indicates the action to be performed by the gateway.
d) Exceptions:
ApplicationException
UnknownEndUserException
InvalidArgumentException
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
7.2.5 Request Application Handling of an 'Off Hook' Condition
|
a) handleOffHook(EndUserIdentifier callingParty, out Action action)
b) Behaviour:
The invocation of handleOffHook requests the application to inform the gateway how to handle the fact that the callingParty tries to initiate a call. The application returns the action, which directs the gateway to perform one of the following actions:
• "Continue", resulting in normal handling in the network, i.e. the calling party can enter digits and, when enough digits are entered, the call is routed based on this information
• "EndCall", resulting in the call being terminated; the exact tone or announcement that will be played to the callingParty is operator-specific
• "Route", resulting in the call being routed to a calledParty specified by the application.
Optionally, in the action parameter, the application can also indicate the charging arrangements, i.e. the name of an operator-specific charging plan that defines who to charge for the call and how much.
c) Parameters:
NAME
TYPE
DESCRIPTION
callingParty
EndUserIdentifier
It contains the address of the caller.
action
Action
OUTPUT. It indicates the action to be performed by the gateway.
d) Exceptions:
ApplicationException
UnknownEndUserException
InvalidArgumentException
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
7.3 Web Service Data Definitions
| |
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
7.3.1 Data Types
|
In addition to the Common Data Types defined in clause 5.1, the following Data Types are specific to this Web Service.
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
7.3.1.1 Action
|
The Action data type is a structure containing the following parameters:
NAME
TYPE
DESCRIPTION
actionToPerform
ActionValues
Indicates the action as described below
routingAddress
EndUserIdentifier
The address to be used in case the action indicates 'Route'
charging
String
OPTIONAL. If present, represents the name of an operator-specific charging plan that defines who to charge for the call and how much. If no charge plan is specified, the charging will be based on an operator-specific charging policy.
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
7.3.1.2 ActionValues
|
The ActionValues data type is an enumeration with the following values:
VALUE
DESCRIPTION
Route
Request to (re-)route the call to the address indicated with routingAddress.
Continue
Request to continue the call without any changes. This will result in normal handling of the event in the network
EndCall
Request to end the call. This will result in termination of the call. The callingParty will receive a tone or announcement.
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
7.3.2 Exceptions
|
All exceptions thrown by this Web Service are Common Exceptions, as defined in clause 5.2.
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
7.4 Web Service Syntax – WSDL
|
The W3C WSDL representation of this API is contained in a set of files which accompany the present document (see Annex A).
The rpc/literal files are
• parlayx_network_initiated_call_types.xsd
• parlayx_network_initiated_call_service_port.wsdl
• parlayx_network_initiated_call_service.wsdl
The rpc/encoded file is
• parlayx_network_initiated_call_service.wsdl.
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
8 SMS
| |
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
8.1 Overview
| |
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
8.1.1 Description
|
Currently, in order to programmatically receive and send SMS it is necessary to write applications using specific protocols to access SMS functions provided by network elements (e.g., SMS-C). This approach requires a high degree of network expertise. Alternatively it is possible to use the Parlay/OSA approach, invoking standard interfaces (e.g., User Interaction or Messaging Service Interfaces) to gain access to SMS capabilities, but these interfaces are usually perceived to be quite complex by IT application developers. Developers must have advanced telecommunication skills to use OSA interfaces.
In this chapter we describe a Parlay X Web Service, SMS for sending and receiving SMS. The overall scope of this Web Service is to provide to application developers primitives to handle SMS in a simple way. In fact, using the SMS Web Service, application developers can invoke SMS functions without specific Telco knowledge.
For sending a message to the network (see clause 8.2 of the present document, Send SMS API), the application invokes a message to send it and must subsequently become active again to poll for delivery status. There is an alternative to this polling mechanism, i.e. an asynchronous notification mechanism implemented with an application-side web service. However it was decided not to provide a notification mechanism in the first release, to make the API as simple as possible, even though the polling mechanism is not as network efficient as the notification mechanism.
For receiving a message from the network, the application may use either polling (see clause 8.4 of the present document, Receive SMS API) or notification (see clause 8.3 of the present document, SMS Notification API) mechanisms. The notification mechanism is more common: network-initiated messages are sent to autonomous application-side web services. Both mechanisms are supported, but the provisioning of the notification-related criteria is not specified.
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
8.1.2 Commercial & Technical Rationale
|
The basic commercial rationale for developing the SMS Web Service is:
• to increase the use of SMS capabilities in software applications
• to empower traditional IT developers to produce large numbers of such applications
• to lower the development cost and time for such applications.
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
8.1.3 Relationship to Similar or Supplanted Specifications
|
Published web services exist that allow transmission of SMS messages, ring-tones and operator logos. For example, the Xmethods site (http://www.xmethods.com/) hosts more than one web service to handle SMS. These web services provide basic SMS capabilities, each using a different interfaces. The SMS Web Service aims to be a standard way to perform SMS operations and to provide more advanced features.
To specify the format of logos and ringtones, the following alternatives exist:
• 3GPP EMS format (see Note).
• Smart Messaging format.
• Other proprietary formats
NOTE: EMS (Enhanced Messaging Service) is an enhancement to SMS that provides the ability to send a combination of simple melodies, pictures, sounds, animations, modified text and standard text as an integrated message for display on an EMS compliant handset. EMS is standardized in 3GPP TS 23.040 [3] where the coding mechanisms and formats are specified.
Both the standardized EMS format and de facto Smart Messaging formats are supported. As an enhancement to SMS for sending content, dedicated methods are proposed taking into account the different content formats applied on the market.
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
8.1.4 Scenarios
|
Figure 3 shows a scenario using the SMS Web Service to send an SMS message from an application. The application invokes a web service to retrieve a weather forecast for a subscriber (1) & (2) and a Parlay X Interface (3) to use the SMS Web Service operations (i.e. to send an SMS). After invocation, the SMS Web Service invokes a Parlay API method (4) using the Parlay/OSA SCS-SMS (User Interaction) interface. This SCS handles the invocation and sends an UCP operation (5) to an SMS-C. Subsequently the weather forecast is delivered (6) to the subscriber.
In an alternative scenario, the Parlay API interaction involving steps (4) and (5) could be replaced with a direct interaction between the SMS Web Service and the Mobile network.
Figure 3: Send SMS Scenario
Figure 4 shows a scenario using the SMS Web Service to deliver a received SMS message to an application. The application receives a Parlay X web service invocation to retrieve an SMS sent by a subscriber (1) & (2). The SMS message contains the e-mail address of the person the user wishes to call. The application invokes a Parlay X Interface (3) to the Third Party Call Web Service in order to initiate the call (4).
Figure 4: Receive SMS Scenario
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
8.2 Send SMS API
|
This subclause describes an initial set of capabilities in terms of message invocations, parameters and data types. The message-based invocations (i.e. of the SMS Web Service by the application) are:
• sendSms
• sendSmsLogo
• sendSmsRingtone
• getSmsDeliveryStatus.
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
8.2.1 Send an SMS Message
|
a) sendSms (EndUserIdentifier[] destinationAddressSet, String senderName, String charging, String message, out String requestIdentifier)
b) Behaviour:
The invocation of sendSms requests to send an SMS, specified by the String message to the specified address (or address set), specified by destinationAddressSet. Optionally the application can also indicate the sender name (senderName), i.e. the string that is displayed on the user's terminal as the originator of the message, and the charging arrangements (charging), i.e. the name of an operator-specific charging plan that defines who to charge for the SMS and how much. By invoking this operation the application requires to receive the notification of the status of the SMS delivery. In order to receive this information the application has to explicitly invoke the getSmsDeliveryStatus. The requestIdentifier, returned by the invocation, can be used to identify the SMS delivery request.
For GSM systems, if message contains characters not in the GSM 7-bit character set, the SMS is sent as a Unicode SMS.
If message is longer than the maximum supported length (e.g. for GSM, 160 GSM 7-bit characters or 70 Unicode characters), the message will be sent as several concatenated short messages.
c) Parameters:
NAME
TYPE
DESCRIPTION
destinationAddressSet
Array of EndUserIdentifier
Addresses to which the SMS will be sent
senderName
String
If present, it indicates the SMS sender name, i.e. the string that is displayed on the user's terminal as the originator of the message.
charging
String
OPTIONAL. If present, represents the name of an operator-specific charging plan that defines who to charge for the SMS and how much. If the named charge plan does not exist, the InvalidArgumentException is thrown. If no charge plan is specified, the sending service/application will be charged, based on an operator-specific charging policy.
message
String
Text to be sent in SMS
requestIdentifier
String
OUTPUT. It identifies a specific SMS delivery request
d) Exceptions:
UnknownEndUserException
InvalidArgumentException
ServiceException
MessageTooLongException
PolicyException
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
8.2.2 Send an SMS Logo
|
a) sendSmsLogo(EndUserIdentifier[] destinationAddressSet, String senderName, String charging, Base64Binary image, SmsFormat smsFormat, out String requestIdentifier)
b) Behaviour:
The invocation of sendSmsLogo requests to send an SMS logo, specified by the byte array image to the specified address (or address set), specified by destinationAddressSet. Optionally the application can also indicate the sender name (senderName), i.e. the string that is displayed on the user's terminal as the originator of the message, and the charging arrangements (charging), i.e. the name of an operator-specific charging plan that defines who to charge for the SMS logo and how much. By invoking this operation the application requires to receive the notification of the status of the SMS delivery. In order to receive this information the application has to explicitly invoke the getSmsDeliveryStatus. The requestIdentifier, returned by the invocation, can be used to identify the SMS delivery request.
c) Parameters:
NAME
TYPE
DESCRIPTION
destinationAddressSet
Array of EndUserIdentifier
Addresses to which the SMS logo will be sent
senderName
String
If present, it indicates SMS sender name, i.e. the string that is displayed on the user's terminal as the originator of the message.
charging
String
OPTIONAL. If present, represents the name of an operator-specific charging plan that defines who to charge for the SMS logo and how much. If the named charge plan does not exist, the InvalidArgumentException is thrown. If no charge plan is specified, the sending service/application will be charged, based on an operator-specific charging policy.
image
Base64Binary
The image in jpeg, gif or png format. The image will be scaled to the proper format.
smsFormat
SmsFormat
Possible values are: 'Ems',
'SmartMessaging'.
requestIdentifier
String
OUTPUT. It identifies a specific SMS delivery request
d) Exceptions:
UnknownEndUserException
InvalidArgumentException
MessageTooLongException
UnsupportedFormatException
ServiceException
PolicyException
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
8.2.3 Send an SMS Ringtone
|
a) sendSmsRingtone(EndUserIdentifier[] destinationAddressSet, String senderName, String charging, String ringtone, SmsFormat smsFormat, out String requestIdentifier)
b) Behaviour:
The invocation of sendSmsRingtone requests to send an SMS ringtone, specified by the String ringtone (in RTX format) to the specified address (or address set), specified by destinationAddressSet. Optionally the application can also indicate the sender name (senderName) i.e. the string that is displayed on the user's terminal as the originator of the message, and the charging arrangements (charging), i.e. the name of an operator-specific charging plan that defines who to charge for the SMS ringtone and how much. By invoking this operation the application requires to receive the notification of the status of the SMS delivery. In order to receive this information the application has to explicitly invoke the getSmsDeliveryStatus. The requestIdentifier, returned by the invocation, can be used to identify the SMS delivery request.
Depending on the length of the ringtone, it may be sent as several concatenated short messages.
c) Parameters:
NAME
TYPE
DESCRIPTION
destinationAddressSet
Array of EndUserIdentifier
Addresses to which the SMS ringtone will be sent
senderName
String
If present, it indicates SMS sender name, i.e. the string that is displayed on the user's terminal as the originator of the message.
charging
String
OPTIONAL. If present, represents the name of an operator-specific charging plan that defines who to charge for the SMS ringtone and how much. If the named charge plan does not exist, the InvalidArgumentException is thrown. If no charge plan is specified, the sending service/application will be charged, based on an operator-specific charging policy.
ringtone
String
The ringtone in RTX format (see Note). (http://www.logomanager.co.uk/help/Edit/RTX.html)
smsFormat
SmsFormat
Possible values are: 'Ems',
'SmartMessaging'.
requestIdentifier
String
OUTPUT. It identifies a specific SMS delivery request
NOTE: RTX Ringtone Specification : An RTX file is a text file, containing the ringtone name, a control subclause and a subclause containing a comma separated sequence of ring tone commands.
d) Exceptions:
UnknownEndUserException
InvalidArgumentException
UnsupportedFormatException
MessageTooLongException
ServiceException
PolicyException
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
8.2.4 Get Current Status of an SMS Delivery
|
a) getSmsDeliveryStatus(String requestIdentifier, out DeliveryStatusType[] deliveryStatus)
b) Behaviour:
The invocation of getSmsDeliveryStatus requests the status of a previous SMS delivery request identified by requestIdentifier. The information on the status is returned in deliveryStatus, which is an array of status related to the request identified by requestIdentifier. The status is identified by a couplet indicating a user address and the associated delivery status. This method can be invoked multiple times by the application even if the status has reached a final value. However, after the status has reached a final value, status information will be available only for a limited period of time that should be specified in an off-line configuration step. The following four different SMS delivery status have been identified:
• 'Delivered': in case of concatenated messages, only when all the SMS-parts have been successfully delivered.
• 'DeliveryUncertain': e.g. because it was handed off to another network.
• 'DeliveryImpossible': unsuccessful delivery; the message could not be delivered before it expired.
• 'MessageWaiting': the message is still queued for delivery.
c) Parameters:
NAME
TYPE
DESCRIPTION
requestIdentifier
String
It identifies a specific SMS delivery request
deliveryStatus
Array of DeliveryStatusType
OUTPUT. It lists the variations on the delivery status of the SMS
d) Exceptions:
UnknownRequestIdentifierException
ServiceException
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
8.3 SMS Notification API
|
This subclause describes an initial set of capabilities in terms of message invocations, parameters and data types. The message-based invocations (i.e. of a notification web service by the SMS Web Service) are:
• notifySmsReception
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
8.3.1 Notify Application of an SMS Message Sent to a Specific Address
|
a) notifySmsReception(String registrationIdentifier, String smsServiceActivationNumber, EndUserIdentifier senderAddress, String message)
b) Behaviour:
The notifySmsReception method must be implemented by a Web Service at the application side. It will be invoked by the Parlay X server to notify the application of the reception of an SMS. The notification will occur if and only if the SMS received fulfils the criteria specified in an off-line provisioning step, identified by the registrationIdentifier. The criteria must at least include an smsServiceActivationNumber, i.e. the SMS destination address that can be "monitored" by the application. The parameter senderAddress contains the address of the sender. The application can apply the appropriate service logic to process the SMS.
c) Parameters:
NAME
TYPE
DESCRIPTION
registrationIdentifier
String
Identifies the off-line provisioning step that enables the application to receive notification of SMS reception according to specified criteria.
smsServiceActivation
Number
String
Number associated with the invoked Message service, i.e. the destination address used by the terminal to send the message.
senderAddress
EndUserIdentifier
It indicates the address sending the SMS
message
String
Text received in the SMS
d) Exceptions:
ApplicationException
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
8.4 Receive SMS API
|
This subclause describes an initial set of capabilities in terms of message invocations, parameters and data types. The message-based invocations (i.e. of the SMS Web Service by the application) are:
• getReceivedSms.
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
8.4.1 Retrieve All SMS Messages Sent to a Specific Address
|
a) getReceivedSms(String registrationIdentifier, out SmsType[] receivedSms)
b) Behaviour:
The invocation of getReceivedSms retrieves all the SMS messages received that fulfil the criteria identified by registrationIdentifier. The method returns only the list of SMS messages received since the previous invocation of the same method, i.e. each time the method is executed the messages returned are removed from the server. Moreover, each SMS message will be automatically removed from the server after a maximum time interval specified in an off-line configuration step.
The received SMS messages are returned in receivedSms. An SMS message is identified by a structure indicating the sender of the SMS message and the content.
c) Parameters:
NAME
TYPE
DESCRIPTION
registrationIdentifier
String
Identifies the off-line provisioning step that enables the application to receive notification of SMS reception according to specified criteria.
receivedSms
Array of SmsType
OUTPUT. It lists the received SMS since last invocation.
d) Exceptions:
UnknownRegistrationIdentifierException
ServiceException
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
8.5 Web Service Data Definitions
| |
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
8.5.1 Data Types
|
In addition to the Common Data Types defined in clause 5.1, the following Data Types are specific to this Web Service.
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
8.5.1.1 DeliveryStatusType
|
The DeliveryStatusType data type is a structure containing the following parameters:
NAME
TYPE
DESCRIPTION
destinationAddress
EndUserIdentifier
It indicates the destination address to which the notification is related
deliveryStatus
DeliveryStatus
Indicates the delivery result for destinationAddress. Possible values are: 'Delivered', 'DeliveryUncertain', 'DeliveryImpossible'.
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
8.5.1.2 DeliveryStatus
|
The DeliveryStatus data type is an enumeration with the following values:
VALUE
DESCRIPTION
Delivered
Successful delivery
DeliveryUncertain
Delivery status unknown: e.g. because it was handed off to another network.
DeliveryImpossible
Unsuccessful delivery; the message could not be delivered before it expired.
MessageWaiting
The message is still queued for delivery. This is a temporary state, pending transition to one of the preceding states.
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
8.5.1.3 SmsType
|
The SmsType data type is a structure containing the following parameters:
NAME
TYPE
DESCRIPTION
message
String
Text received in SMS
senderAddress
EndUserIdentifier
It indicates address sending the SMS
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
8.5.1.4 SmsFormat
|
The SmsFormat data type is an enumeration with the following values:
VALUE
DESCRIPTION
Ems
Enhanced Messaging Service, standardized in 3GPP TS 23.040 [3], which defines a logo/ringtone format
SmartMessagingTM
Defines a logo/ringtone format
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
8.5.2 Exceptions
|
In addition to the Common Exceptions defined in clause 5.2, there are exceptions specific to this Web Service. Similar to the Common Exceptions, each Web Service-specific exception is assigned an eight-character identifier. This identifier is interpreted as described in clause 5.2, except that the first 3 characters uniquely identify this Web Service.
The following exceptions are specific to this Web Service:
UNIQUE ID
TEXT STRING
MEANING
SMS1000E
UnsupportedFormatException
The smsFormat supplied is not one of the permitted values of the SmsFormat data type.
SMS1001E
UnknownRegistration
IdentifierException
The registrationIdentifier supplied is not known by the server
SMS1002E
UnknownRequestIdentifier
Exception
The requestIdentifier supplied does not relate to any known SMS request or has expired.
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
8.6 Web Service Syntax – WSDL
|
The W3C WSDL representation of this API is contained in a set of files which accompany the present document (see Annex A).
The rpc/literal files are
• parlayx_sms_types.xsd
• parlayx_sms_service_port.wsdl
• parlayx_sms_send_service.wsdl
• parlayx_sms_receive_service.wsdl
• parlayx_sms_notification_service_port.wsdl
• parlayx_sms_notification_service.wsdl
The rpc/encoded files are
• parlayx_sms_service.wsdl
• parlayx_sms_notification_service.wsdl
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
9 Multimedia Message
| |
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
9.1 Overview
| |
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
9.1.1 Description
|
Currently, in order to programmatically receive and send Multimedia Messages, it is necessary to write applications using specific protocols to access MMS functions provided by network elements (e.g., MMS-C). This approach requires application developers to have a high degree of network expertise.
This contribution defines a Multimedia Message Web Service that can map to SMS, EMS, MMS, IM, E-mail etc.
The choice is between defining one set of APIs per messaging network or a single set common to all networks; e.g. we could define sendMMS, sendEMS, sendSMS, … or just use sendMessage. Although the more specific the API the easier it is to use, there are advantages to a single set of network-neutral APIs. These advantages include:
• improved service portability
• lower complexity, by providing support for generic user terminal capabilities only.
For this version of the Parlay X specification, we provide sets of APIs for two messaging web services: SMS-specific APIs (as described in clause 8) and Multimedia Message APIs (this clause), which provides generic messaging features (including SMS).
For sending a message to the network (see clause 9.2 of the present document, Send Message API), the application invokes a message to send it and must subsequently become active again to poll for delivery status. There is an alternative to this polling mechanism, i.e. an asynchronous notification mechanism implemented with an application-side web service. However it was decided not to provide a notification mechanism in the first release, to make the API as simple as possible, even though the polling mechanism is not as network efficient as the notification mechanism.
For receiving a message from the network, the application may use either polling (see clause 9.3 of the present document, Receive Message API) or notification (see clause 9.4 of the present document, Message Notification API) mechanisms. The notification mechanism is more common: network-initiated messages are sent to autonomous application-side web services. Both mechanisms are supported, but the provisioning of the notification-related criteria is not specified.
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
9.1.2 Commercial & Technical Rationale
|
The scope of this Web Service is much more than an enhancement of the Parlay X SMS Web Service. The purpose is not to add more SMS features, but to form a generic multimedia adapted messaging API. The reason to incorporate SMS in the API is mainly to create one set of APIs for messaging instead of one set per network. We believe that the benefits of a single set of APIs, i.e. service portability and the ability to serve different handsets or even multiple sub-networks using common APIs, is highly beneficial for both the Network Operators and the Service Providers.
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
9.1.3 Relationship to Similar or Supplanted Specifications
|
This Web Service includes functions implemented in the SMS Web Service.
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
9.1.4 Scenarios
|
Figure 5 shows an example scenario using sendMessage and getMessageDeliveryStatus to send data to subscribers and to determine if the data has been received by the subscriber. The application invokes a web service to retrieve a stock quote (1) & (2) and sends the current quote - sendMessage - using the Parlay X Interface (3) of the Multimedia Message Web Service. After invocation, the Multimedia Message Web Service sends the message to an MMS-C using the MM7 interface (4) for onward transmission (5) to the subscriber over the Mobile network
Later, when the next quote is ready, the application checks to see - getMessageDeliveryStatus - if the previous quote has been successfully delivered to the subscriber. If not, it may for instance perform an action (not shown) to provide a credit for the previous message transmission. This way, the subscriber is only charged for a stock quote if it is delivered on time.
Figure 5: Multimedia Messaging Scenario
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
9.2 Send Message API
|
This subclause describes an initial set of capabilities in terms of message invocations, parameters and data types. The message-based invocations (i.e. of the Multimedia Message Web Service by the application) are:
• sendMessage
• getMessageDeliveryStatus
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
9.2.1 Send a Multimedia Message
|
a) sendMessage(EndUserIdentifier [] destinationAddressSet, String senderAddress, String subject, MessagePriority priority, String charging, out String requestIdentifier) Attachment[content]
b) Behaviour:
Request to send a Message to a set of destination addresses, returning a requestIdentifier to identify the message. The requestIdentifier can subsequently be used by the application to poll for the message status, i.e. using getMessageDeliveryStatus to see if the message has been delivered or not. The content is sent as a SOAP-Attachment (see note) encoded using MIME or DIME.
NOTE: SOAP-Attachment is used because specification of the WS-Attachments standard is not yet complete. The decision to use SOAP-Attachment may be revisited in future releases. Please refer to your SOAP/WSDL toolkit documentation for information on populating or retrieving a SOAP-Attachment.
c) Parameters:
NAME
TYPE
DESCRIPTION
destinationAddressSet
Array of EndUserIdentifier
Destination addresses for the Message.
senderAddress
String
OPTIONAL. If present, indicates Message sender address. This parameter is not allowed for all 3rd party providers. Parlay X server needs to handle this according to a SLA for the specific application and its use can therefore result in a PolicyException.
subject
String
OPTIONAL. If present, it indicates the message subject. If mapped to SMS this parameter will be used as the senderAddress, even if a separate senderAddress is provided.
priority
MessagePriority
OPTIONAL. If present, represents the priority of the message. If not defined, the network will assign a priority based on an operator policy.
charging
String
OPTIONAL. If present, represents the name of an operator-specific charging plan that defines who to charge for the message and how much. If the named charge plan does not exist, the InvalidArgumentException is thrown. If no charge plan is specified, the sending service/application will be charged, based on operator-specific charging policy.
requestIdentifier
String
OUTPUT. It is a correlation identifier that is used in a getMessageDeliveryStatus message invocation, i.e. to poll for the delivery status of all of the sent Messages.
Input Attachments
content
MIME or DIME format
Data to be sent with Message, i.e. in MIME or DIME format and sent as a SOAP-Attachment
d) Exceptions
UnknownEndUserException
InvalidArgumentException
ServiceException
PolicyException
MessageTooLongException
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
9.2.2 Get Current Status of a Multimedia Message Delivery
|
a) getMessageDeliveryStatus(String requestIdentifier, out DeliveryStatusType[] deliveryStatus)
b) Behaviour:
This is a poll method used by the application to retrieve delivery status for each message sent as a result of a previous sendMessage message invocation. The requestIdentifier parameter identifies this previous message invocation.
c) Parameters:
NAME
TYPE
DESCRIPTION
requestIdentifier
String
Identifier related to the delivery status request.
deliveryStatus
Array of DeliveryStatusType
OUTPUT. It is an array of status of the messages that were previously sent. Each array element represents a sent message: i.e. its destination address and its delivery status.
d) Exceptions
InvalidArgumentException
ServiceException
Policy Exception
UnknownRequestIdentifierException
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
9.3 Receive Message API
|
This subclause describes an initial set of capabilities in terms of message invocations, parameters and data types. The message-based invocations (i.e. of the Multimedia Message Web Service by the application) are:
• getReceivedMessages
• getMessageURIs
• getMessage
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
9.3.1 Provide Application with Multimedia Messages Sent to the Application
|
a) getReceivedMessages(String registrationIdentifier, MessagePriority priority, out MessageRef [] messageRef)
b) Behaviour:
This method enables the application to poll for new messages associated with a specific registrationIdentifier. If the registrationIdentifier is not specified, the Parlay X server will return references to all messages sent to the application. The process of binding different registrationIdentifier parameters to applications is an off-line process. The Parlay X gateway shall not allow an application to poll for messages using registrationIdentifier parameters that are not associated with the application. The priority parameter may be used by the application to retrieve references to higher priority messages, e.g. if Normal is chosen only references to high priority and normal priority messages are returned. If the priority parameter is omitted all message references are returned.
c) Parameters:
NAME
TYPE
DESCRIPTION
registrationIdentifier
String
Identifies the off-line provisioning step that enables the application to receive notification of Message reception according to specified criteria.
priority
MessagePriority
OPTIONAL. The priority of the messages to poll from the Parlay X gateway. All messages of the specified priority and higher will be retrieved. If not specified, all messages shall be returned, i.e. the same as specifying Low.
messageRef
Array of MessageRef
OUTPUT. It contains an array of messages received according to the specified filter of registrationIdentifier and priority.
d) Exceptions
InvalidArgumentException
ServiceException
PolicyException
UnknownRegistrationIdentifierException
|
e3edf551830c62df14a4eaeee607bff5
|
29.199
|
9.3.2 Retrieve URI References to the Parts of a Multimedia Message
|
getMessageURIs(String messageRefIdentifier, out MessageURI message)
b) Behaviour:
This method will read the different parts of the message, create local files in the Parlay Gateway and return URI references to them. The application can then simply read each file or just have them presented as links to the end-user. The URIs to the files will be active for an agreed time.
c) Parameters:
NAME
TYPE
DESCRIPTION
messageRefIdentifier
String
The identity of the message to retrieve.
message
MessageURI
OUTPUT. It contains the complete message, i.e. the textual part of the message, if such exists, and a list of file references for the message attachments, if any.
d) Exceptions
InvalidArgumentException
ServiceException
PolicyException
UnknownMessageException
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.