9 IDL Interface Definitions

29.1983GPPOpen Service Architecture (OSA) Application Programming Interface (API) - Part 1Release 1999TS

The OSA API definitions have been divided into several CORBA modules. The common data definitions are placed in the root module while each of the specific service capability feature API definitions are being assigned their own module directly under that root. Each specific SCF functions, like User Status, have their data and interface definitions collocated. This structure has the advantage that explicit scoping is kept to a minimum.

The IDLs defined for the specific SCFs assumes that the OSA common definitions (interfaces and data) are provided in the org.threegpp.osa module within a file name called OSA.idl

Module Name

Description

IDL file name

org.threegpp.osa

Common data/interface definitions

OSA.idl

org.threegpp.osa.fw

common Framework data-types

FW.idl

org.threegpp.osa.fw.discovery

Discovery data-types and interfaces

DISC.idl

org.threegpp.osa.fw.trust_and_security

Trust and Security date-types and interfaces

TandS.idl

org.threegpp.osa.fw.integrity

Integrity management data-types and interfaces

IM.idl

org.threegpp.osa.fw.registration

Registration data-types and interfaces

REG.idl

org.threegpp.osa.cc

Call Control data-types

CC.idl

org.threegpp.osa.cc.gcc

Generic Call Control interfaces

GCC.idl

org.threegpp.osa.cc.ecc

data-types and interfaces specific for Enhanced Call Control. This is only needed to compile the User Interaction IDL

ECC.idl

org.threegpp.osa.ui

User Interaction data-types

UI.idl

org.threegpp.osa.ui.gui

User Interaction interfaces

GUI.idl

org.threegpp.osa.dsc

Data Session data-types and interfaces

DSC.idl

org.threegpp.osa.mm

Common mobility data definitions (root)

MM.idl

org.threegpp.osa.mm.ul

Network User Location (UL)

MMul.idl

org.threegpp.osa.mm.us

User Status (US)

MMus.idl

org.threegpp.osa.termcap

Terminal Capabilities

TERMCAP.idl

Some of the interfaces contain more operations than defined in the interface classes of Chapter 6. These operations must return a “Method not supported” exception in case the interface is implemented on a SCS based on this specification.

9.1 Generic IDL

#ifndef __OSA_DEFINED

#define __OSA_DEFINED

module org

{

module threegpp

{

module osa

{

/**************************************************************************/

// Primitive data types

/**************************************************************************/

typedef boolean TpBoolean; // Defines a Boolean data type

typedef long TpInt32; // Defines a signed 32 bit integer

typedef float TpFloat; // Defines a single precision real number.

typedef string TpString; // Defines a string comprising length and data.

// Primitive based OSA datatypes

typedef TpInt32 TpDuration; // This data type is a TpInt32 representing a

// time interval in milliseconds. A value of "-1" defines

// infinite duration and a value of "-2" represents default

// duration.

typedef TpInt32 TpSessionID; // Defines a network unique session ID. OSA

// uses this ID to identify sessions, e.g. call or call leg

// sessions, within an object implementing an interface

// capable of handling multiple sessions. For the different

// OSA service capability feature, the sessionIDs are unique

// only in the context of a manager instantiation (e.g., within

// the context of one generic call control manager). As such

// if an application creates two instances of the same SCF

// manager it shall use different instantiations of the

// callback objects which implement the callback interfaces.

typedef TpInt32 TpAssignmentID; // This data type is identical to a TpInt32. It

// specifies a number which identifies an individual

// event notification enabled by the application or

// OSA service capability feature.

typedef sequence < TpSessionID> TpSessionIDSet;

exception TpGeneralException

{

TpInt32 exceptionType;

};

const TpInt32 P_RESULT_INFO_UNDEFINED = 0;

const TpInt32 P_INVALID_DOMAIN_ID = 1;

const TpInt32 P_INVALID_AUTH_CAPABILITY = 2;

const TpInt32 P_INVALID_AGREEMENT_TEXT = 3;

const TpInt32 P_INVALID_SIGNING_ALGORITHM = 4;

const TpInt32 P_INVALID_INTERFACE_NAME = 5;

const TpInt32 P_INVALID_SERVICE_ID = 6;

const TpInt32 P_INVALID_EVENT_TYPE = 7;

const TpInt32 P_SERVICE_NOT_ENABLED = 8;

const TpInt32 P_INVALID_ASSIGNMENT_ID = 9;

const TpInt32 P_INVALID_PARAMETER = 10;

const TpInt32 P_INVALID_PARAMETER_VALUE = 11;

const TpInt32 P_PARAMETER_MISSING = 12;

const TpInt32 P_RESOURCES_UNAVAILABLE = 13;

const TpInt32 P_TASK_REFUSED = 14;

const TpInt32 P_TASK_CANCELLED = 15;

const TpInt32 P_INVALID_DATE_TIME_FORMAT = 16;

const TpInt32 P_NO_CALLBACK_ADDRESS_SET = 17;

const TpInt32 P_INVALID_SIGNATURE = 18;

const TpInt32 P_INVALID_SERVICE_TOKEN = 19;

const TpInt32 P_ACCESS_DENIED = 20;

const TpInt32 P_INVALID_PROPERTY = 21;

const TpInt32 P_METHOD_NOT_SUPPORTED = 22;

const TpInt32 P_NO_ACCEPTABLE_AUTH_CAPABILITY = 23;

const TpInt32 P_INVALID_INTERFACE_TYPE = 24;

const TpInt32 P_SERVICE_ACCESS_TYPE = 25;

const TpInt32 P_SERVICE_ACCESS_DENIED = 26;

const TpInt32 P_USER_NOT_SUBSCRIBED = 48;

const TpInt32 P_APPLICATION_NOT_ACTIVATED = 49;

const TpInt32 P_USER_PRIVACY = 50;

/**************************************************************************/

/********************* Date and Time related data definitions *************/

/**************************************************************************/

// This data type is identical to a TpString. It specifies the data in

// accordance with International Standard ISO 8601. This is defined as the

// string of characters in the following format:

// YYYY-MM-DD

// where the date is specified as:

// YYYY four digits year

// MM two digits month

// DD two digits day

// The date elements are separated by a hyphen character (-).

typedef TpString TpDate;

// This data type is identical to a TpString. It specifies the time in accordance

// with International Standard ISO 8601. This is defined as the string of

// characters in the following format:

// HH:MM:SS.mmm

// or

// HH:MM:SS.mmmZ

// where the time is specified as:

// HH two digits hours (24h notation)

// MM two digits minutes

// SS two digits seconds

// mmm three digits fractions of a second (i.e. milliseconds)

// The time elements are separated by a colon character (:).The date and time

// are separated by a space. Optionally, a capital letter Z may be appended

// to the time field to indicate Universal Time (UTC). Otherwise, local time

// is assumed.

typedef TpString TpTime;

// This data type is identical to TosaString. It specifies the data and time

// in accordance with International Standard ISO 8601. This is defined as the

// string of characters in the following format:

//

// YYYY-MM-DD HH:MM:SS.mmm

// or YYYY-MM-DD HH:MM:SS.mmmZ

//

// Example:

// The 4 December 1998, at 10:30 and 15 seconds is encoded as the string:

// 1998-12-04 10:30:15.000

// for local time, or in UTC it would be:

// 1998-12-04 10:30:15.000Z

typedef TpString TpDateAndTime;

/**************************************************************************/

// Address related data definitons

/**************************************************************************/

// Defines whether an address can be presented to an end user

enum TpAddressPresentation

{

P_ADDRESS_PRESENTATION_UNDEFINED, // Undefined

P_ADDRESS_PRESENTATION_ALLOWED, // Presentation Allowed

P_ADDRESS_PRESENTATION_RESTRICTED, // Presentation Restricted

P_ADDRESS_PRESENTATION_ADDRESS_NOT_AVAILABLE // Address not available for

// presentation

};

// Defines whether an address has been screened by the application

enum TpAddressScreening

{

P_ADDRESS_SCREENING_UNDEFINED, // Undefined

P_ADDRESS_SCREENING_USER_VERIFIED_PASSED, // user provided address verified

// and passed

P_ADDRESS_SCREENING_USER_NOT_VERIFIED, // user provided address not verified

P_ADDRESS_SCREENING_USER_VERIFIED_FAILED, // user provided address verified and

// failed

P_ADDRESS_SCREENING_NETWORK // Network provided address

};

// Defines the address plan (or numbering plan) used. It is also used to indicate

// whether an address is actually defined in a TAddress data element

enum TpAddressPlan

{

P_ADDRESS_PLAN_NOT_PRESENT, // No Address Present

P_ADDRESS_PLAN_UNDEFINED, // Undefined

P_ADDRESS_PLAN_IP, // IP

P_ADDRESS_PLAN_MULTICAST, // Multicast

P_ADDRESS_PLAN_UNICAST, // Unicast

P_ADDRESS_PLAN_E164, // E.164

P_ADDRESS_PLAN_AESA, // AESA

P_ADDRESS_PLAN_URL, // URL

P_ADDRESS_PLAN_NSAP, // NSAP

P_ADDRESS_PLAN_SMTP, // SMTP

P_ADDRESS_PLAN_NOT_USED,

P_ADDRESS_PLAN_X400 // X.400

};

// Defines the reasons why an address is invalid.

enum TpAddressError

{

P_ADDRESS_INVALID_UNDEFINED, // Undefined error

P_ADDRESS_INVALID_MISSING, // Mandatory address not present

P_ADDRESS_INVALID_MISSING_ELEMENT, // Mandatory address element not present

P_ADDRESS_INVALID_OUT_OF_RANGE, // Address is outside of the valid range

P_ADDRESS_INVALID_INCOMPLETE, // Address is incomplete

P_ADDRESS_INVALID_CANNOT_DECODE // Address cannot be decoded

};

// Defines the structure of data elements that specifies an address

struct TpAddress

{

TpAddressPlan plan;

TpString astring;

TpString name;

TpAddressPresentation presentation;

TpAddressScreening screening;

TpString subAddressString;

};

// Defined a collection of TpAddress elements

typedef sequence < TpAddress> TpAddressSet;

// Defined a collection of TpAddress elements

typedef TpAddress TpAddressRange;

// This data type is identical to a TpString and contains a URL address.

typedef TpString TpURL;

// This data type is identical to a TpString. It specifies price information.

// This is defined as the string of characters (digits) in the following format:

// DDDDDD.DD

typedef TpString TpPrice;

struct TpChargePerTime {

TpInt32 InitialCharge; /*Initial charge amount (in currency units * 0.0001)*/

TpInt32 CurrentChargePerMinute; /* Current tariff (in currency units * 0.0001)*/

TpInt32 NextChargePerMinute; /* Next tariff (in currency units * 0.0001) after tariff switch

Only used in setAdviceOfCharge()*/

};

enum TpAoCOrderCategory {

P_CHARGE_ADVICE_INFO, /* Set of GSM Charge Advice Information elements according to 3GPP TS 22.024*/

P_CHARGE_PER_TIME, /* Charge per time*/

P_CHARGE_NETWORK /* Operator specific charge plan specification, e.g. charging table name / charging table entry*/

};

/* Defines the Sequence of Data Elements that specify theCharging Advice Information elements according to 3GPP TS 22.024.*/

struct TpCAIElements {

TpInt32 UnitsPerInterval; /* Units per interval */

TpInt32 SecondsPerTimeInterval; /* Seconds per time interval */

TpInt32 ScalingFactor; /* Scaling factor */

TpInt32 UnitIncrement; /* Unit increment */

TpInt32 UnitsPerDataInterval; /* Units per data interval */

TpInt32 SegmentsPerDataInteral; /* Segments per data interal */

TpInt32 InitialSecsPerTimeInterval; /* Initial secs per time interval */

};

struct TpChargeAdviceInfo {

TpCAIElements CurrentCAI ; /* Current tariff*/

TpCAIElements NextCAI ; /* Next tariff after tariff switch*/

};

/* Defines the Tagged Choice of Data Elements that specify the charge plan */

union TpAoCOrder switch(TpAoCOrderCategory) {

case P_CHARGE_ADVICE_INFO:

TpChargeAdviceInfo ChargeAdviceInfo;

case P_CHARGE_PER_TIME:

TpChargePerTime ChargePerTime;

case P_CHARGE_NETWORK:

TpString NetworkCharge;

};

struct TpAoCInfo {

TpAoCOrder ChargeOrderType; /* Charge order*/

TpString Currency; /* Currency unit according to ISO-4217:1995*/

};

/**************************************************************************/

// base OSA interface

/**************************************************************************/

// All application, framework and service capability features interfaces inherit

// from the following interface. This API Base Interface does not provide any

// additional methods.

interface IpOsa

{

};

// All service capability feature interfaces inherit from the following interface.

interface IpService : IpOsa

{

// This method specifies the reference address of the callback interface

// that a SCF uses to invoke methods on the application.

void setCallback(in IpOsa appInterface) raises(TpGeneralException);

void setCallbackWithSessionID(in IpOsa appInterface, in TpSessionID sessionID) raises(TpGeneralException);

};

};

};

};

#endif

9.2 Framework IDL

9.2.1 Common Data Types for the Framework

#include <OSA.idl>

module org{

module threegpp{

module osa{

module fw{

typedef TpString TpClientAppID; // Identifies the client appl to the framework.

typedef sequence <TpClientAppID> TpClientAppIDList;

/* Defines either the framework or the type of entity attempting to access the framework

The framework

A client application

An enterprise operator

A registered service

A service supplier */

enum TpDomainIDType

{

P_FW,

P_CLIENT_APPLICATION,

P_ENT_OP,

P_REGISTERED_SERVICE,

P_SERVICE_SUPPLIER

};

typedef TpString TpEntOpID;

typedef sequence < TpEntOpID > TpEntOpIDList;

typedef TpString TpFwID;

typedef TpString TpServiceSupplierID;

/* Defines the Tagged Choice of Data Elements that specify either the framework or the type of entity

attempting to access the framework.

Tag Element Type

TpDomainIDType */

union TpDomainID switch (TpDomainIDType)

{

case P_FW:

TpFwID FwID;

case P_CLIENT_APPLICATION:

TpClientAppID ClientAppID;

case P_ENT_OP:

TpEntOpID EntOpID;

case P_REGISTERED_SERVICE:

TpServiceID ServiceID;

case P_SERVICE_SUPPLIER:

TpServiceSupplierID ServiceSupplierID;

};

typedef TpString TpPropertyName;

typedef TpString TpPropertyValue;

typedef sequence < TpProperty > TpPropertyList;

struct TpProperty {

TpPropertyName PropertyName;

TpPropertyValue PropertyValue;

};

typedef TpString TpServiceID; // A string of characters, generated automatically by the

// Framework and comprising a TpUniqueServiceNumber,

// TpServiceNameString, and a number of relevant

// TpServiceSpecString, concatenated using a forward

// separator (/), that uniquely identifies an instance of a

// SCF interface.

typedef sequence <TpServiceID> TpServiceIDList;

typedef TpString TpServiceNameString; // Uniquely identifies the name of an SCF

// interface. For OSA release 99 the following

// values have been defined: NULL (no SCF name),

// P_CALL_CONTROL, P_USER_INTERACTION,

// P_USER_LOCATION_CAMEL, P_TERMINAL_CAPABILITIES and

// P_USER_STATUS.

typedef TpString TpServiceSpecString; // Uniquely identifies the name of a SCF

// specialization interface. For OSA release 99

// the following values have been defined: NULL

// no SCF specialization) and P_CALL.

typedef TpString TpUniqueServiceNumber; // A string of characters that represents a

// unique number.

enum TpServicePropertyMode {

NORMAL, // The value of the corresponding SCF property type may optionally be

// provided.

MANDATORY, // The value of the corresponding SCF property type must be provided

// at SCF registration.

_READONLY, // The value of the corresponding SCF property is optional, nut once

// given a value it may not be modified.

MANDATORY_READONLY // The value of the corresponding SCF property type must be provided

// and may not be modified subsequently.

};

typedef TpString TpServicePropertyTypeName;

typedef TpString TpServicePropertyName;

typedef sequence <TpServicePropertyName> TpServicePropertyNameList;

typedef TpString TpServicePropertyValue;

typedef sequence <TpServicePropertyValue> TpServicePropertyValueList;

struct TpServiceProperty { // Describes a SCF property

TpServicePropertyName ServicePropertyName;

TpServicePropertyValueList ServicePropertyValueList;

TpServicePropertyMode ServicePropertyMode;

};

typedef sequence <TpServiceProperty> TpServicePropertyList;

typedef TpString TpServiceTypeName;

typedef sequence <TpServiceTypeName> TpServiceTypeNameList;

struct TpService { // Describes a registered SCF.

TpServiceID ServiceID;

TpServicePropertyList ServicePropertyList;

};

typedef sequence <TpService> TpServiceList;

struct TpServiceDescription { // Describes the properties of a registered SCF.

TpServiceTypeName ServiceTypeName;

TpServicePropertyList ServicePropertyList;

};

struct TpServiceTypeProperty { // Describes a SCF property.

TpServicePropertyName ServicePropertyName;

TpServicePropertyMode ServicePropertyMode;

TpServicePropertyTypeName ServicePropertyTypeName;

};

typedef sequence <TpServiceTypeProperty> TpServiceTypePropertyList;

struct TpServiceTypeDescription { // Describes a SCF type.

TpServiceTypePropertyList ServiceTypePropertyList;

TpServiceTypeNameList ServiceTypeNameList;

TpBoolean EnabledOrDisabled;

};

};};};};

9.2.2 Service Discovery IDL

#include <fw.idl>

module org{

module threegpp{

module osa{

module fw{

module discovery{

/***************************************************************************************/

// Interface definitions //

/***************************************************************************************/

/* The Service Discovery Framework interface is used by the client application to

know what types of services are supported by the Framework, and what are their

properties; and to obtain the services its subscription allows access to. */

interface IpServiceDiscovery : IpOsa {

/* This method is invoked by the client application to obtain the names of all service

types that are in the Framework repository. */

void listServiceTypes (

out TpServiceTypeNameList listTypes // The names of the requested service types.

) raises (TpGeneralException);

/* This method is invoked by the client application to obtain the detailed description of

a particular service type. */

void describeServiceType (

in TpServiceTypeName name, // Identifies the service

// type to be described.

out TpServiceTypeDescription serviceTypeDescription // Describes the specified

// service type.

) raises (TpGeneralException);

/* This method is invoked by the client application to obtain the IDs of the services

that meet its requirements. */

void discoverService (

in TpServiceTypeName serviceTypeName, // Type of the required service.

in TpServicePropertyList desiredPropertyList, // Properties that the discovered set

// of SCFs should satisfy.

in TpInt32 max, // Maximum number of SCFs that are

// to be returned.

out TpServiceList serviceList // A list of matching SCFs.

) raises (TpGeneralException);

/* This method is invoked by the client application to obtain a list of subscribed

SCFs that they are allowed to access. */

void listSubscribedServices (

out TpServiceList serviceList // A list of subscribed SCFs.

) raises (TpGeneralException);

};

};};};};};

9.2.3 Trust and Security Management IDL

#include <fw.idl>

module org{

module threegpp{

module osa{

module fw{

module trust_and_security{

/***************************************************************************************/

// Data definitions //

/***************************************************************************************/

typedef TpString TpAccessType; // The type of access interface requested by the client

// application. For OSA release 99 the following value

// has been defined: P_ACCESS.

typedef TpString TpAuthType; // The type of authentication mechanism requested by the

// client. For OSA release 99 the following values has

// been defined:

// P_AUTHENTICATION (indicates use of the OSA

// authentication interfaces).

typedef TpString TpAuthCapability; // The authentication capabilities that could be supported

// by the OSA. For OSA release 99 the following values

// have been defined: NULL (indicates no client

// capabilities, P_DES_56, P_DES_128, P_RSA_512 and P_RSA_1024).

typedef TpString TpAuthCapabilityList; // A string of multiple TpAuthCapability

// concatenated using a commas.

struct TpAuthDomain

{

TpDomainID DomainID;

IpOSA AuthInterface;

};

typedef TpPropertyList TpEndAccessProperties;

typedef TpString TpInterfaceName; // Identifies the names of the framework SCFs that are to be

// supported by the OSA API. For release 99 these are,

// P_DISCOVERY, P_OAM

// P_LOAD_MANAGER,

// P_FAULT_MANAGER,

// P_HEARTBEAT_MANAGEMENT,

// P_REGISTRATION

struct TpServiceAccessControl {

TpString Policy; // Access control policy information controlling access to the

// service feature.

TpString TrustLevel; // The level of trust that the network operator has assigned to the

// client application.

};

typedef TpString TpServiceToken; // Uniquely identifies a SCF.

struct TpSignatureAndServiceMgrRef {

TpString DigitalSignature; // The digital signature of the Framework for the service

// agreement.

IpOsa ServiceMgrInterface;

};

typedef TpString TpSigningAlgorithm; // Identifies the signing algorithm that must be

// used. For OSA release 99 the follwing values have

// been defined: NULL (indicates no signing algorithm

// is required), P_MD5_RSA_512 and P_MD5_RSA_1024.

typedef TpString TpFwID;

struct TpFwAuth {

TpFwID FwID;

IpOsa FwAuthInterface;

};

/***************************************************************************************/

// Interface definitions //

/***************************************************************************************/

/* The Initial Framework interface is used by the client application to initiate the mutual

authentication with the Framework and, when this is finished successfully, to request access

to it. */

interface IpInitial : IpOsa {

/* This method is invoked by the client application to start the process of mutual

authentication with the framework, and request the use of a specific authentication method.

*/

void initiateAuthentication (

in TpAuthDomain appDomain, // Identifies the client to the framework.

in TpAuthType authType, // Allows the client application to request a

// specific type of authentication mechanism.

out TpAuthDomain fwDomain // Provides a framework identifier, and a reference

// to framework authentication interface.

) raises (TpGeneralException);

/* This method is invoked by the client application, once mutual authentication is

achieved, to request access to the framework and specify the type of access desired. */

void requestAccess (

in TpAccessType accessType, // Identifies the type of access interface requested by

// the client application.

in IpOsa appAccessInterface, // Provides a reference to the access interface of the

// client application.

out IpOsa fwAccessInterface // Provides a reference to call the access interface of

// the framework.

) raises (TpGeneralException);

};

/* The Access Framework interface is used by the client application to perform the mechanisms

necessary for it to obtain access to SCFs. */

interface IpAccess : IpOsa {

/* This method is invoked by the client application to obtain interface references to other

framework interfaces. */

void obtainInterface (

in TpInterfaceName interfaceName, // The name of the framework interface to which a

// reference to the interface is requested.

out IpOsa fwInterface // The requested interface reference.

) raises (TpGeneralException);

/* This method is invoked by the client application to obtain interface references to other

framework interfaces, when it is required to supply a callback interface to the framework. */

void obtainInterfaceWithCallback (

in TpInterfaceName interfaceName, // The name of the framework interface to which

// a reference to the interface is requested.

in IpOsa appInterface, // This is the reference to the client application

// interface which is used for callbacks.

out IpOsa fwInterface // The requested interface reference.

) raises (TpGeneralException);

/* This method may be invoked by the client application to check whether it has been

granted permission to access the specified SCF and, if granted, the level of trust that

will be applied. */

void accessCheck (

in TpServiceToken serviceToken,

in TpString securityContext, // A group of security relevant

// attributes.

in TpString securityDomain, // The security domain in which

// the client application is

// operating.

in TpString group, // Used to define the access

// rights associated with all

// clients that belong to that

// group.

in TpString serviceAccessTypes, // Defined by the specific

// security model in use.

out TpServiceAccessControl serviceAccessControl // The access control policy

// information controlling

// access to the service

// capability feature, and the

// trustLevel that the network

// operator has assigned to the client

// application.

) raises (TpGeneralException);

/* This method is invoked by the client application to identify the SCF that it wishes

to use. */

void selectService (

in TpServiceID serviceID, // Identifies the SCF.

out TpServiceToken serviceToken // A free format text token returned by

// the framework, which can be signed as

// part of a service agreement.

) raises (TpGeneralException);

/* This method is invoked by the client application to request that the framework sign an

agreement on the SCF, which allows the client application to use the SCF. */

void signServiceAgreement (

in TpServiceToken serviceToken, // Used to identify the SCF

// instance requested by the

// client application.

in TpString agreementText, // The agreement text to be

// signed by the framework.

in TpSigningAlgorithm signingAlgorithm, // The algorithm used to compute

// the digital signature.

out TpSignatureAndServiceMgrRef signatureAndServiceMgr // A reference to a structure

// that contains the digital

// signature of the framework

// for the service agreement,

// and a reference to the

// SCF manager interface of

// the SCF.

) raises (TpGeneralException);

/* This method is invoked by the client application to terminate an agreement for the

specified SCF. */

void terminateServiceAgreement (

in TpServiceToken serviceToken, // Identifies the service agreement to be terminated.

in TpString terminationText, // Describes the reason for the termination of the

// service agreement.

in TpString digitalSignature // Used by the framework to check that the

// terminationText has been signed by the client.

) raises (TpGeneralException);

/* This method is invoked by the client application to end the access session

with the Framework. */

void endAccess () raises (TpGeneralException);

};

/* The Access client application interface is used by the Framework to perform the steps that

are necessary in order to allow it to SCF access. */

interface IpAppAccess : IpOsa {

/* This method is invoked by the Framework to request that client application sign an

agreement on a specified SCF. */

void signServiceAgreement (

in TpServiceToken serviceToken, // Identifies the SCF instance to which

// this service agreement corresponds.

in TpString agreementText, // Agreement text that has to be signed by the

// client application.

in TpSigningAlgorithm signingAlgorithm, // Algorithm used to compute the digital

// signature.

out TpString digitalSignature // Signed version of a hash of the service

// token and agreement text given by the

// framework.

) raises (TpGeneralException);

/* This method is invoked by the Framework to terminate an agreement for a specified

SCF. */

void terminateServiceAgreement (

in TpServiceToken serviceToken, // Identifies the SCF agreement to be terminated.

in TpString terminationText, // Describes the reason for the termination.

in TpString digitalSignature // Used by the Framework to confirm its identity to the

// client.

) raises (TpGeneralException);

/* This method is invoked by the Framework to end the client application’s access session

with the framework. */

void terminateAccess (

in TpString terminationText, // Describes the reason for the termination of

// the access session.

in TpSigningAlgorithm signingAlgorithm, // The algorithm used to compute the digital

// signature.

in TpString digitalSignature // Used by the Framework to confirm its

// identity to the client.

) raises (TpGeneralException);

};

/* The Authentication Framework interface is used by client application to perform its part of

the mutual authentication process with the Framework necessary to be allowed to use any of the

other interfaces supported by the Framework. */

interface IpAuthentication : IpOsa {

/* This method is invoked by the client application to start the authentication process,

informed the Framework of the authentication mechanisms it supports, and be informed by its

of its preferred choice. */

void selectAuthMethod (

in TpAuthCapabilityList auths, // Informs the Framework of the authentication

// mechanisms supported by the client

// application.

out TpAuthCapability prescribedMethod // Indicates the mechanism preferred by the

// framework.

) raises (TpGeneralException);

/* This method is invoked by the client application to authenticate the framework using the

mechanism indicated in the parameter prescribedMethod. */

void authenticate (

in TpAuthCapability prescribedMethod, // Specifies the method accepted by that the

// framework for authentication.

in TpString challenge, // The challenge presented by the client

// application to be responded to by the

// framework.

out TpString response // The response of the framework to the

// challenge of the client application.

) raises (TpGeneralException);

/* This method is invoked by the client application to to abort the authentication

process.*/

void abortAuthentication() raises (TpGeneralException);

};

/* The Authentication client application interface is used by the Framework to authenticate

the client application. */

interface IpAppAuthentication : IpOsa {

/* This method is invoked by the Framework to authenticate the client application using the

mechanism indicated in prescribedMethod. */

void authenticate (

in TpAuthCapability prescribedMethod, // The agreed authentication method.

in TpString challenge, // The challenge presented by the Framework.

out TpString response

) raises (TpGeneralException);

/* This method is invoked by the Framework to abort the authentication process. */

void abortAuthentication() raises (TpGeneralException);

};

};};};};};

9.2.4 Integrity Management IDL

#include <fw.idl>

module org{

module threegpp{

module osa{

module fw{

module integrity{

/***************************************************************************************/

// Data definitions //

/***************************************************************************************/

typedef TpString TpActivityTestRes; // An implementation specific result, whose values

// are Framework provider specific.

struct TpTimeInterval { // A time interval.

TpDateAndTime StartTime;

TpDateAndTime StopTime;

};

enum TpInterfaceFault { // The cause of the interface fault detected.

INTERFACE_FAULT_UNDEFINED, // Undefined.

INTERFACE_FAULT_LOCAL_FAILURE, // A fault in the local API software or hardware has been

// detected.

INTERFACE_FAULT_GATEWAY_FAILURE, // A fault in the gateway API software or hardware has been

// detected.

INTERFACE_FAULT_PROTOCOL_ERROR // An error in the protocol used on the client-gateway link

// has been detected.

};

struct TpFaultStats { // Statistics on a per fault type basis.

TpInterfaceFault Fault;

TpInt32 Occurrences; // The number of separate instances of this fault

// during the period.

TpInt32 MaxDuration; // The duration in seconds of the longest fault.

TpInt32 TotalDuration; // The cumulative total during the period.

TpInt32 NumberOfClientsAffected; // Those informed of the fault by the Framework.

};

typedef sequence <TpFaultStats> TpFaultStatsSet;

struct TpFaultStatsRecord { // The set of fault information records to be returned for the

// requested time period.

TpTimeInterval Period;

TpFaultStatsSet FaultRecords;

};

typedef TpInt32 TpActivityTestID; // Used as a token to match activity test requests

// with their results.

enum TpSvcUnavailReason { // The reason why a SCF is unavailable.

SERVICE_UNAVAILABLE_UNDEFINED, // Undefined.

SERVICE_UNAVAILABLE_LOCAL_FAILURE, // The local API software or hardware has failed.

SERVICE_UNAVAILABLE_GATEWAY_FAILURE, // The gateway API software or hardware has failed.

SERVICE_UNAVAILABLE_OVERLOADED, // The SCF is fully overloaded.

SERVICE_UNAVAILABLE_CLOSED // The SCF has closed itself.

};

enum TpAPIUnavailReason { // The reason why the API is unavailable.

API_UNAVAILABLE_UNDEFINED, // Undefined.

API_UNAVAILABLE_LOCAL_FAILURE, // The local API software or hardware has failed.

API_UNAVAILABLE_GATEWAY_FAILURE, // The gateway API software or hardware has failed.

API_UNAVAILABLE_OVERLOADED, // The gateway is fully overloaded.

API_UNAVAILABLE_CLOSED, // The gateway has closed itself.

API_UNAVAILABLE_PROTOCOL_FAILURE // The protocol used on the client-gateway link has failed.

};

enum TpLoadLevel { // The load level values.

LOAD_LEVEL_NORMAL, // Normal load.

LOAD_LEVEL_OVERLOAD, // Overload.

LOAD_LEVEL_SEVERE_OVERLOAD // Severe overload.

};

struct TpLoadThreshold{ // The load threshold value.

TpFloat LoadThreshold;

};

struct TpLoadInitVal { // The pair of load level and associated load threshold values.

TpLoadLevel LoadLevel;

TpLoadThreshold LoadThreshold;

};

struct TpLoadPolicy { // The load balancing policy.

TpString LoadPolicy;

};

enum TpLoadStatisticEntityType {

P_LOAD_STATISTICS_FW_TYPE,

P_LOAD_STATISTICS_SVC_TYPE,

P_LOAD_STATISTICS_APP_TYPE

};

union TpLoadStatisticEntityID switch(TpLoadStatisticEntityType)

{

case P_LOAD_STATITICS_FW_TYPE:

TpFwID FrameworkID;

case P_LOAD_STATITICS_SVC_TYPE:

TpServiceID ServiceID;

case P_LOAD_STATITICS_APP_TYPE:

TpClientAppID ClientAppID;

};

struct TpLoadStatisticData {

TpFloat LoadValue; // Expressed in percentage.

TpLoadLevel LoadLevel;

};

enum TpLoadStatisticError {

P_LOAD_INFO_ERROR_UNDEFINED,

P_LOAD_INFO_UNAVAILABLE

};

enum TpLoadStatisticInfoType {

P_LOAD_STATISTICS_VALID,

P_LOAD_STATISTICS_INVALID

};

union TpLoadStatisticInfo switch(TpLoadStatisticInfoType)

{

case P_LOAD_STATISTICS_VALID:

TpLoadStatisticData LoadStatisticData;

case P_LOAD_STATISTICS_INVALID:

TpLoadStatisticError LoadStatisticError;

};

struct TpLoadStatistic {

TpLoadStatisticEntityID LoadStatisticEntityID;

TpDateAndTime TimeStamp;

TpLoadStatisticInfo LoadStatisticInfo;

};

typedef sequence <TpLoadStatistic> TpLoadStatisticList;

/***************************************************************************************/

// Interface definitions //

/***************************************************************************************/

/* The Heartbeat Framework interface is used by the client application to supervise the

Framework or a SCF. */

interface IpHeartBeat : IpOsa {

/* This method is invoked by the client application to make the service or Framework

supervision. */

void send (

in TpSessionID session // The heartbeat session.

) raises (TpGeneralException);

};

/* The Heartbeat client application interface is used by the Framework to supervise the client

application. */

interface IpAppHeartBeat : IpOsa {

/* This method is invoked by the Framework to make the client application supervision. */

void send (

in TpSessionID session // The heartbeat session.

) raises (TpGeneralException);

};

/* The Heartbeat Management Framework interface is used by the client application to

initialise a heartbeat supervision of the client application. */

interface IpHeartBeatMgmt : IpOsa {

/* This method is invoked by the client application to register at the Framework for

heartbeat supervision. */

void enableHeartBeat (

in TpDuration duration, // Duration in milliseconds between heartbeats.

in IpAppHeartBeat appInterface, // The callback interface the heartbeat is calling.

out TpSessionID session // The heartbeat session.

) raises (TpGeneralException);

/* This method is invoked by the client application to stop its heartbeat supervision. */

void disableHeartBeat (

in TpSessionID session // The heartbeat session.

) raises (TpGeneralException);

/* This method is invoked by the client application to change the heartbeat period. */

void changeTimePeriod (

in TpDuration duration, // Duration in milliseconds between heartbeats.

in TpSessionID session // The heartbeat session.

) raises (TpGeneralException);

};

/* The Heartbeat Management client application interface is used by the Framework to

initialise its heartbeat supervision of the Framework. */

interface IpAppHeartBeatMgmt : IpOsa {

/* This method is invoked by the Framework to register at the client application for its

heartbeat supervision. */

void enableAppHeartBeat (

in TpDuration duration, // Time interval in milliseconds between the heartbeats.

in IpHeartBeat fwInterface, // The callback interface the heartbeat is calling.

in TpSessionID session // The heartbeat session.

) raises (TpGeneralException);

/* This method is invoked by the Framework to stop the heartbeat supervision by the

application. */

void disableAppHeartBeat (

in TpSessionID session // The heartbeat session.

) raises (TpGeneralException);

/* This method is invoked by the Framework to change the heartbeat period. */

void changeTimePeriod (

in TpDuration duration, // Interval in milliseconds between the heartbeats.

in TpSessionID session // The heartbeat session.

) raises (TpGeneralException);

};

/* The Load Manager Framework interface is used by the client application for load balancing

management. */

interface IpLoadManager : IpOsa {

/* This method is invoked by the client application to notify framework its current load

level (0,1, or 2) when the load level on the application has changed. */

void reportLoad (

in TpLoadLevel loadLevel // The application’s load level.

) raises (TpGeneralException);

/* This method is invoked by the client application to request load statistic records for

the framework and specified SCFs. */

void queryLoadReq (

in TpServiceIDList serviceIDs, // Specifies the framework and SCFs for which the

// load statistics shall be reported.

in TpTimeInterval timeInterval // The time interval within which the load statistics

// are generated.

) raises (TpGeneralException);

/* This method is invoked by the client application to report load statistics back to the

framework that requested the information. */

void queryAppLoadRes (

in TpLoadStatisticList loadStatistics // The application’s load statistics.

) raises (TpGeneralException);

/* This method is invoked by the client application to return an error response to the

framework that requested the application’s load statistics information. */

void queryAppLoadErr (

in TpLoadStatisticErrorList loadStatisticsError // The error code associated with the

// failed attempt to retrieve the

// application’s load statistics.

) raises (TpGeneralException);

/* This method is invoked by the client application to register the client application for

load management under various load conditions. */

void registerLoadController (

in TpServiceIDList serviceIDs // Specifies the framework and SCFs to be

// registered for load control.

) raises (TpGeneralException);

/* This method is invoked by the client application to unregister for load management. */

void unregisterLoadController (

in TpServiceIDList serviceIDs // Specifies the framework or SCFs to be

// unregistered for load control.

) raises (TpGeneralException);

/* This method is invoked by the client application to resume load management notifications

to it from the framework and specified SCFs. */

void resumeNotification (

in TpServiceIDList serviceIDs // Specifies the framework and SCFs for which

// notifications are to be resumed.

) raises (TpGeneralException);

/* This method is invoked by the client application to suspend load management

notifications to it from the framework and specified SCFs, while it handles a temporary

load condition. */

void suspendNotification (

in TpServiceIDList serviceIDs // Specifies the framework and SCFs for which

// notifications are to be suspended.

) raises (TpGeneralException);

};

/* The Load Manager client application interface is used by the Framework to access the

application load balancing SCF. */

interface IpAppLoadManager : IpOsa {

/* This method is invoked by the Framework to request for load statistic records produced

by a specified application. */

void queryAppLoadReq (

in TpServiceIDList serviceIDs, // Specifies the SCFs or application for which the

// load statistics shall be reported.

in TpTimeInterval timeInterval // The time interval within which the load statistics

// are generated.

) raises (TpGeneralException);

/* This method is invoked by the Framework to return load statistics to the application

which requested the information. */

void queryLoadRes (

in TpLoadStatisticList loadStatistics // The load statistics supplied by the

// Framework.

) raises (TpGeneralException);

/* This method is invoked by the Framework to return an error code to the application that

requested load statistics. */

void queryLoadErr (

in TpLoadStatisticErrorList loadStatisticsError // The error code supplied by the

// Framework.

) raises (TpGeneralException);

/* This method is invoked by the Framework to disable load control activity at the client

application based on policy, after the load level of the Framework or SCF which has

been registered for load control moves back to normal. */

void disableLoadControl (

in TpServiceIDList serviceIDs // Specifies the framework and SCFs for which the

// load has changed to normal.

) raises (TpGeneralException);

/* This method is invoked by the Framework to enable load management activity at the client

application based on the policy, upon detecting load condition change. */

void enableLoadControl (

in TpLoadStatisticList loadStatistics // The new load statistics.

) raises (TpGeneralException);

/* This method is invoked by the Framework to resume the notification from an application

for its load status after the detection of load level change at the Framework and the

evaluation of the load balancing policy. */

void resumeNotification() raises (TpGeneralException);

/* This method is invoked by the Framework to suspend the notification from an application

for its load status after the detection of load level change at the Framework and the

evaluation of the load balancing policy. */

void suspendNotification() raises (TpGeneralException);

};

/* The Fault Manager Framework interface is used by the client application to inform the

Framework of events that affect the integrity of the Framework and SCFs, and to request

information about the integrity of the system. */

interface IpFaultManager : IpOsa {

/* This method may be invoked by the client application to test that the Framework or a

SCF is operational. */

void activityTestReq (

in TpActivityTestID activityTestID, // Identifier provided by the client

// application to correlate the

// response with this request.

in TpServiceID svcID // Identifies for which SCF the client

// application is requesting the activity test

// be done.

) raises (TpGeneralException);

/* This method is invoked by the client application to return the result of a previously

requested activity test. */

void appActivityTestRes (

in TpActivityTestID activityTestID, // Used by the Framework to correlate this

// response with the original request.

in TpActivityTestRes activityTestResult // Result of the activity test.

) raises (TpGeneralException);

/* This method is invoked by the client application to inform the Framework that it can no

longer use the indicated SCF. */

void svcUnavailableInd (

in TpServiceID serviceID // Identity of the SCF which can no longer be used.

) raises (TpGeneralException);

/* This method is invoked by the client application to request fault statistics from the

Framework. */

void genFaultStatsRecordReq (

in TpTimeInterval timePeriod, // The period over which the fault statistics

// are to be generated.

in TpServiceIDs serviceIDList // The SCFs that the application would like

// to have included in the general fault

// statistics record.

) raises (TpGeneralException);

};

/* The Fault Manager client application interface is used by the Framework to inform the

application of events that affect the integrity of the Framework, SCF or client

application. */

interface IpAppFaultManager : IpOsa {

/* This method is invoked by the Framework, in response to an activityTestReq, to return

the result of the activity test in this method. */

void activityTestRes (

in TpActivityTestID activityTestID, // The identifier provided to correlate this

// response with the original request.

in TpActivityTestRes activityTestResult // Result of the activity test.

) raises (TpGeneralException);

/* This method is invoked by the Framework to request that the client application carries

out an activity test to check that is it operating correctly. */

void appActivityTestReq (

in TpActivityTestID activityTestID // The identifier provided to correlate this

// response with the original request.

) raises (TpGeneralException);

/* This method is invoked by the Framework to notify the client application of a failure

within the Framework. */

void fwFaultReportInd (

in TpInterfaceFault fault // The fault that has been detected.

) raises (TpGeneralException);

/* This method is invoked by the Framework to notify the client application that a

previously reported fault has been rectified. */

void fwFaultRecoveryInd (

in TpInterfaceFault fault // The fault from which the framework has recovered.

) raises (TpGeneralException);

void fwUnavailableInd (

in TpFwUnavailReason reason

) raises (TpGeneralException);

/* This method is invoked by the Framework to inform the client application that it can no

longer use the indicated SCF due to a failure. */

void svcUnavailableInd (

in TpServiceID serviceID, // Identity of the SCF which can no longer be used.

in TpSvcUnavailReason reason // The reason why the SCF is no longer available.

) raises (TpGeneralException);

/* This method is invoked by the Framework to provide fault statistics to a client

application in response to a genFaultStatsRecordReq. */

void genFaultStatsRecordRes (

in TpFaultStatsRecord faultStatistics, // The fault statistics record.

in TpServiceIDList serviceIDs // The SCFs that have been included in the

// general fault statistics record.

) raises (TpGeneralException);

};

/* The OAM Framework interface is used by the client application to query the system date and

time, for synchronization purposes. */

interface IpOAM : IpOsa {

/* This method is invoked by the client application to interchange the system an client

application date and time. */

void systemDateTimeQuery (

in TpDateAndTime clientDateAndTime, // The date and time of the client.

out TpDateAndTime systemDateAndTime // The date and time of the system.

) raises (TpGeneralException);

};

/* The OAM client application interface is used by the Framework to query the application date

and time, for synchronization purposes. */

interface IpAppOAM : IpOsa {

/* This method is invoked by the Framework to interchange the system an client application

date and time. */

void systemDateTimeQuery (

in TpDateAndTime systemDateAndTime, // The date and time of the system.

out TpDateAndTime clientDateAndTime // The date and time of the client.

) raises (TpGeneralException);

};

};};};};};

9.2.5 Registration IDL

#include <fw.idl>

module org{

module threegpp{

module osa{

module fw{

module registration{

/***************************************************************************************/

// Interface definitions //

/***************************************************************************************/

/* The Service Registration Framework interface provides the methods used for the registration

of network SCFs at the Framework. */

interface IpServiceRegistration : IpOsa {

/* This method is used to register a SCF in the Framework, for subsequent discovery by

the applications. */

void registerService (

in TpServiceTypeName serviceTypeName,

in TpServicePropertyList servicePropertyList,

out TpServiceID serviceID

) raises (TpGeneralException);

/* This method informs the Framework of the availability of a service factory for a

previously registered SCF. */

void announceServiceAvailability (

in TpServiceID serviceID,

in IpOsa serviceFactory

) raises (TpGeneralException);

/* This method is used to remove a registered SCF from the Framework. */

void unregisterService (

in TpServiceID serviceID

) raises (TpGeneralException);

/* This method is used to ebtain the decription of a certain SCF as it was registered in

the Framework. */

void describeService (

in TpServiceID serviceID,

out TpServiceDescription serviceDescription

) raises (TpGeneralException);

};

/* The Service Factory Framework interface provides the Framework with access to a manager

interface of a network SCF to be given to an application. */

interface IpSvcFactory : IpOsa {

/* This method returns an SCF manager interface reference for a specified application. */

void getServiceManager (

in TpDomainID application,

in TpServicePropertyList serviceProperties,

out IpServiceOsa serviceManager

) raises (TpGeneralException);

};

};};};};};

9.3 Call Control

9.3.1 Common Data Types for Call Control

// source file: CC.idl

// Generic Call Data description

#ifndef __OSA_CC_DEFINED

#define __OSA_CC_DEFINED

#include <OSA.idl>

#include <UI.idl>

module org

{

module threegpp

{

module osa

{

module cc

{

/* Defines the mechanism that will be used to alert a called party. */

typedef TpInt32 TpCallAlertingMechanism;

/* Defines the bearer service associated with the call. */

enum TpCallBearerService

{

P_CALL_BEARER_SERVICE_UNKNOWN, /* Bearer capability information

unknown at this time*/

P_CALL_BEARER_SERVICE_SPEECH, /* Speech*/

P_CALL_BEARER_SERVICE_DIGITALUNRESTRICTED, /* Unrestricted digital information*/

P_CALL_BEARER_SERVICE_DIGITALRESTRICTED, /* Restricted digital information*/

P_CALL_BEARER_SERVICE_AUDIO, /* 3.1 kHz audio*/

P_CALL_BEARER_SERVICE_DIGITALUNRESTRICTEDTONES, /* Unrestricted digital information

with tones/announcements*/

P_CALL_BEARER_SERVICE_VIDEO /*Video*/

};

/*This data defines the bearer capabilities associated with the call. (3GPP TS 24.002) This

information is network operator specific and may not always be available because there

is no standard protocol to retrieve the information */

enum TpCallNetworkAccessType

{

P_CALL_NETWORK_ACCESS_TYPE_UNKNOWN, /* Network type information unknown at this time */

P_CALL_NETWORK_ACCESS_TYPE_POT, /* POTS */

P_CALL_NETWORK_ACCESS_TYPE_ISDN, /* ISDN */

P_CALL_NETWORK_ACCESS_TYPE_DIALUPINTERNET, /* Dial-up Internet */

P_CALL_NETWORK_ACCESS_TYPE_XDSL, /* xDSL */

P_CALL_NETWORK_ACCESS_TYPE_WIRELESS /* Wireless */

};

/* Defines the category of a calling or called party (e.g. call priority, payphone,

prepaid).*/

enum TpCallPartyCategory

{

P_CALL_PARTY_CATEGORY_UNKNOWN, /*calling party’s category unknown at this time*/

P_CALL_PARTY_CATEGORY_OPERATOR_F, /* operator, language French*/

P_CALL_PARTY_CATEGORY_OPERATOR_E, /* operator, language English*/

P_CALL_PARTY_CATEGORY_OPERATOR_G, /* operator, language German*/

P_CALL_PARTY_CATEGORY_OPERATOR_R, /* operator, language Russian*/

P_CALL_PARTY_CATEGORY_OPERATOR_S, /* operator, language Spanish*/

P_CALL_PARTY_CATEGORY_ORDINARY_SUB, /* ordinary calling subscriber*/

P_CALL_PARTY_CATEGORY_PRIORITY_SUB, /* calling subscriber with priority*/

P_CALL_PARTY_CATEGORY_DATA_CALL, /* data call (voice band data) */

P_CALL_PARTY_CATEGORY_TEST_CALL, /* test call*/

P_CALL_PARTY_CATEGORY_PAYPHONE /* payphone*/

};

/* This data type defines the tele-service associated with the call. (Q.763: User Teleservice Information, Q.931: High Layer Compatitibility Information, and 3GPP TS 22.003)Defines the tele-service associated with the call (e.g. speech, video, fax, file transfer, browsing). */

enum TpCallTeleService

{

P_CALL_TELE_SERVICE_UNKNOWN, /* Teleservice information unknown at this time*/

P_CALL_TELE_SERVICE_TELEPHONY, /* Telephony */

P_CALL_TELE_SERVICE_FAX_2_3, /* Facsimile Group 2/3 */

P_CALL_TELE_SERVICE_FAX_4_I, /* Facsimile Group 4, Class I */

P_CALL_TELE_SERVICE_FAX_4_II_III, /* Facsimile Group 4, Classes II and III */

P_CALL_TELE_SERVICE_VIDEOTEX_SYN, /* Syntax based Videotex */

P_CALL_TELE_SERVICE_VIDEOTEX_INT, /* International Videotex interworking via gateways or interworking units */

P_CALL_TELE_SERVICE_TELEX, /* Telex service*/

P_CALL_TELE_SERVICE_MHS, /* Message Handling Systems */

P_CALL_TELE_SERVICE_OSI, /* OSI application*/

P_CALL_TELE_SERVICE_FTAM, /* FTAM application*/

P_CALL_TELE_SERVICE_VIDEO, /* Videotelephony*/

P_CALL_TELE_SERVICE_VIDEO_CONF, /* Videoconferencing*/

P_CALL_TELE_SERVICE_AUDIOGRAPH_CONF, /* Audiographic conferencing*/

P_CALL_TELE_SERVICE_MULTIMEDIA, /* Multimedia services*/

P_CALL_TELE_SERVICE_CS_INI_H221, /* Capability set of initial channel of H.221*/

P_CALL_TELE_SERVICE_CS_SUB_H221, /* Capability set of subsequent channel of H.221*/

P_CALL_TELE_SERVICE_CS_INI_CALL, /* Capability set of initial channel associated with an active 3.1 kHz audio or speech call.*/

P_CALL_TELE_SERVICE_DATATRAFFIC, /* Data traffic.*/

P_CALL_TELE_SERVICE_EMERGENCY_CALLS, /* Emergency Calls*/

P_CALL_TELE_SERVICE_SMS_MT_PP, /* Short message MT/PP*/

P_CALL_TELE_SERVICE_SMS_MO_PP, /* Short message MO/PP*/

P_CALL_TELE_SERVICE_CELL_BROADCAST, /* Cell Broadcast Service*/

P_CALL_TELE_SERVICE_ALT_SPEECH_FAX_3, /* Alternate speech and facsimile group 3*/

P_CALL_TELE_SERVICE_AUTOMATIC_FAX_3, /* Automatic Facsimile group 3*/

P_CALL_TELE_SERVICE_VOICE_GROUP_CALL, /* Voice Group Call Service*/

P_CALL_TELE_SERVICE_VOICE_BROADCAST /* Voice Broadcast Service*/

};

/* Defines a specific call event report type. */

enum TpCallAppInfoType

{

P_CALL_APP_UNDEFINED, /* Undefined */

P_CALL_APP_ALERTING_MECHANISM, /* The alerting mechanism or pattern to use */

P_CALL_APP_NETWORK_ACCESS_TYPE, /* The network access type (e.g. ISDN) */

P_CALL_APP_TELE_SERVICE, /* Indicates the tele-service (e.g. speech) and related info such as clearing programme */

P_CALL_APP_BEARER_SERVICE, /* Indicates the bearer service (e.g. 64kb/s unrestricted data). */

P_CALL_APP_PARTY_CATEGORY, /* The category of the calling or called party */

P_CALL_APP_PRESENTATION_ADDRESS, /* The address to be presented to other call parties */

P_CALL_APP_GENERIC_INFO, /* Carries unspecified application-SCF information */

P_CALL_APP_ADDITIONAL_ADDRESS /* Indicates an additional address */

};

/* Defines the Tagged Choice of Data Elements that specify call application-related specific information. */

union TpCallAppInfo switch(TpCallAppInfoType)

{

case P_CALL_APP_TELE_SERVICE:

TpCallTeleService CallAppTeleService;

case P_CALL_APP_BEARER_SERVICE:

TpCallBearerService CallAppBearerService;

case P_CALL_APP_PARTY_CATEGORY:

TpCallPartyCategory CallAppPartyCategory;

case P_CALL_APP_PRESENTATION_ADDRESS:

TpAddress CallAppPresentationAddress;

case P_CALL_APP_GENERIC_INFO:

TpString CallAppGenericInfo;

case P_CALL_APP_ADDITIONAL_ADDRESS:

TpAddress CallAppAdditionalAddress;

case P_CALL_APP_ALERTING_MECHANISM:

TpCallAlertingMechanism CallAppAlertingMechanism;

case P_CALL_APP_NETWORK_ACCESS_TYPE:

TpCallNetworkAccessType CallAppNetworkAccessType;

};

typedef sequence <TpCallAppInfo> TpCallAppInfoSet;

enum TpCallChargeOrderCategory

{

P_CALL_CHARGE_PER_TIME, /* Charge per time*/

P_CALL_CHARGE_NETWORK /* Operator specific charge plan specification, e.g. charging table name / charging table entry*/

};

/* Defines the Tagged Choice of Data Elements that specify the charge plan for the call. */

union TpCallChargeOrder switch(TpCallChargeOrderCategory)

{

case P_CALL_CHARGE_PER_TIME: TpChargePerTime ChargePerTime;

case P_CALL_CHARGE_NETWORK: TpString NetworkCharge;

};

/* Defines the Sequence of Data Elements that specify the charge plan for the call This data type is identical to a TpString, and defines the call charge plan to be used for the call. The values of this data type are operator specific. */

struct TpCallChargePlan

{

TpCallChargeOrder ChargeOrderType;

TpString Currency;

TpString AdditionalInfo;

};

const TpInt32 P_EVENT_NAME_UNDEFINED = 0; // Undefined

const TpInt32 P_EVENT_GCCS_OFFHOOK_EVENT = 1; // Offhook event

const TpInt32 P_EVENT_GCCS_ADDRESS_COLLECTED_EVENT = 2; // Address information collected

const TpInt32 P_EVENT_GCCS_ADDRESS_ANALYSED_EVENT = 4; // Address information is analysed

const TpInt32 P_EVENT_GCCS_CALLED_PARTY_BUSY = 8; // Called party is busy

const TpInt32 P_EVENT_GCCS_CALLED_PARTY_UNREACHABLE = 16; // Called party is unreachable

const TpInt32 P_EVENT_GCCS_NO_ANSWER_FROM_CALLED_PARTY = 32; // No answer from called party

const TpInt32 P_EVENT_GCCS_ROUTE_SELECT_FAILURE = 64; // Failure in routing the call

const TpInt32 P_EVENT_GCCS_ANSWER_FROM_CALL_PARTY = 128; // Party answered call

typedef TpInt32 TpCallEventName; /*Defines the names of event being notified. */

enum TpCallNotificationType

{

P_ORIGINATING, // The notification is related to the originating user in the call.

P_TERMINATING // The notification is related to the terminating user in the call.

};

struct TpCallEventCriteria

{

TpAddressRange DestinationAddress; /*Destination address or address range*/

TpAddressRange OriginationAddress; /*Origination address or address range */

TpCallEventName CallEventName; /*Name of the event(s) */

TpCallNotificationType CallNotificationType; /*Indicates whether the criteria are related to the originating or terminating user in the call */

TpCallMonitorMode MonitorMode;

};

/* Defines a sequence of data elements that specify a requested call event notification criteria with the associated assignmentID */

struct TpCallEventCriteriaResult

{

TpCallEventCriteria EventCriteria;

TpInt32 AssignmentID;

};

/* Defines a set of TpCallEventCriteriaResult */

typedef sequence <TpCallEventCriteriaResult> TpCallEventCriteriaResultSet;

//Defines the type of notification.

//Indicates whether it is related to the originating of the terminating user in the call.

struct TpCallEventInfo

{

TpAddress DestinationAddress;

TpAddress OriginatingAddress;

TpAddress OriginalDestinationAddress;

TpAddress RedirectingAddress;

TpCallAppInfoSet CallAppInfo;

TpCallEventName CallEventName;

TpCallNotificationType CallNotificationType;

TpCallMonitorMode MonitorMode;

};

/* Defines the Sequence of Data Elements that specify the cause of the release of a call.*/

struct TpCallReleaseCause {

TpInt32 Value;

TpInt32 Location;

};

/* Defines the Sequence of Data Elements that specify the reason for the call ending.*/

struct TpCallEndedReport

{

TpSessionID CallLegSessionID;

TpCallReleaseCause Cause;

};

/* Defines a specific call error. */

enum TpCallErrorType

{

P_CALL_ERROR_UNDEFINED, /* Undefined */

P_CALL_ERROR_INVALID_ADDRESS, /* The operation failed because an invalid address was given */

P_CALL_ERROR_INVALID_STATE /* The call was not in a valid state for the requested operation */

};

/* Defines the Tagged Choice of Data Elements that specify additional call error and call error specific information. This is also used to specify call leg errors and call information errors. */

union TpCallAdditionalErrorInfo switch(TpCallErrorType)

{

case P_CALL_ERROR_INVALID_ADDRESS: TpAddressError CallErrorInvalidAddress;

default: short Dummy; // allows initialization of the union in the default case

};

/* Defines the Sequence of Data Elements that specify the additional information relating to an undefined call error. */

struct TpCallError

{

TpCallAdditionalErrorInfo AdditionalErrorInfo;

TpCallErrorType ErrorType;

TpDateAndTime ErrorTime;

};

/* Defines the cause of the call fault detected. */

enum TpCallFault

{

P_CALL_FAULT_UNDEFINED, /* Undefined */

P_CALL_TIMEOUT_ON_RELEASE, /* Final report has been sent to the application, but the application did not explicitly release or deassign the call object, within a specified time. */

P_CALL_TIMEOUT_ON_INTERRUPT /* Application did not instruct the gateway how to handle the call within a specified time, after the gateway reported an event that was requested by the application in interrupt mode.*/

};

/* Defines the type of call information requested and reported */

const TpInt32 P_CALL_INFO_UNDEFINED = 0; /* Undefined */

const TpInt32 P_CALL_INFO_TIMES = 1; /* Relevant call times */

const TpInt32 P_CALL_INFO_RELEASE_CAUSE = 2; /* Call release cause. */

const TpInt32 P_CALL_INFO_INTERMEDIATE = 4; /* Send only intermediate reports (i.e., when a party leaves the call). */

typedef TpInt32 TpCallInfoType;

/* Defines the Sequence of Data Elements that specify the call information requested. Information that was not requested may be undefined or not present. */

struct TpCallInfoReport

{

TpCallInfoType CallInfoType;

TpDateAndTime CallInitiationStartTime;

TpDateAndTime CallConnectedToResourceTime;

TpDateAndTime CallConnectedToDestinationTime;

TpDateAndTime CallEndTime;

TpCallReleaseCause Cause;

};

/* Defines the mode that the call will monitor for events, or the mode that the call is in following a detected event. */

enum TpCallMonitorMode

{

P_CALL_MONITOR_MODE_INTERRUPT, /* The call event is intercepted by the call control SCF and call processing is interrupted. The application is notified of the event and call processing resumes following an appropriate API call or network event (such as a call release) */

P_CALL_MONITOR_MODE_NOTIFY, /* The call event is detected by the call control SCF but not intercepted. The application is notified of the event and call processing continues */

P_CALL_MONITOR_MODE_DO_NOT_MONITOR /* Do not monitor for the event */

};

/* Defines the type of call overload that has been detected (and possibly acted upon) by the network. */

enum TpCallOverloadType

{

P_CALL_OVERLOAD_TYPE_UNDEFINED, /* Infinite interval (do not admit any calls) */

P_CALL_OVERLOAD_TYPE_NEW_CALLS, /* New calls to the application are causing overload (i.e. inbound overload) */

P_CALL_OVERLOAD_TYPE_ROUTED_CALLS /* Calls being routed to destination or origination addresses by the application are causing overload (i.e. outbound overload) */

};

/* Defines a specific call event report type. */

enum TpCallReportType

{

P_CALL_REPORT_UNDEFINED, /* Undefined */

P_CALL_REPORT_PROGRESS, /* Call routing progress event */

P_CALL_REPORT_ALERTING, /* Call alerting at address */

P_CALL_REPORT_ANSWER, /* Call answered at address */

P_CALL_REPORT_BUSY, /* Called address refused call due to busy */

P_CALL_REPORT_NO_ANSWER, /* No answer at called address */

P_CALL_REPORT_DISCONNECT, /* Call disconnect requested by address */

P_CALL_REPORT_REDIRECTED,

P_CALL_REPORT_SERVICE_CODE,

P_CALL_REPORT_ROUTING_FAILURE

};

/* Defines the Tagged Choice of Data Elements that specify additional call report information. */

union TpCallAdditionalReportInfo switch(TpCallReportType)

{

case P_CALL_REPORT_BUSY: TpCallReleaseCause Busy;

case P_CALL_REPORT_DISCONNECT: TpCallReleaseCause CallDisconnect;

case P_CALL_REPORT_REDIRECTED: TpAddress ForwardAddress;

case P_CALL_REPORT_SERVICE_CODE: TpCallReleaseCause ServiceCode;

case P_CALL_REPORT_ROUTING_FAILURE: TpCallReleaseCause RoutingFailure;

default: short Dummy; // allows initialization of the union in the default case

};

struct TpCallReport

{

TpCallMonitorMode MonitorMode;

TpDateAndTime CallEventTime;

TpCallReportType CallReportType;

TpCallAdditionalReportInfo AdditionalReportInfo;

};

/* Defines the different types of service codes that can be received during the call.*/

enum TpCallServiceCodeType

{

P_CALL_SERVICE_CODE_UNDEFINED, /* The type of service code is unknown. The corresponding string is operator specific.*/

P_CALL_SERVICE_CODE_DIGITS, /* The user entered a digit sequence during the call. The corresponding string is an ascii representation of the received digits. */

P_CALL_SERVICE_CODE_FACILITY, /* A facility information element is received. The corresponding string contains the facility information element as defined in ITU Q.932*/

P_CALL_SERVICE_CODE_U2U, /* A user-to-user message was received. The associated string contains the content of the user-to-user information element. */

P_CALL_SERVICE_CODE_HOOKFLASH, /* The user performed a hookflash, optionally followed by some digits. The corresponding string is an ascii representation of the entered digits. */

P_CALL_SERVICE_CODE_RECALL /* The user pressed the register recall button, optionally followed by some digits. The corresponding string is an ascii representation of the entered digits. */

};

/* Defines the Sequence of Data Elements that specify the service code and type of service code received during a call. The service code type defines how the value string should be interpreted. Defines the service code received during a call. For example, this may be a digit sequence, user-user information, recall, flash-hook or ISDN Facility Information Element. This data type is identical to a TpString. The coding of this data type is operator specific. */

struct TpCallServiceCode

{

TpCallServiceCodeType CallServiceCodeType;

TpString ServiceCodeValue;

};

/* Defines the Tagged Choice of Data Elements that specify specific criteria. */

union TpCallAdditionalReportCriteria switch(TpCallReportType)

{

case P_CALL_REPORT_NO_ANSWER: TpDuration NoAnswerDuration;

case P_CALL_REPORT_SERVICE_CODE: TpCallServiceCode ServiceCode;

default: short Dummy; // allows initialization of the union in the default case

};

/* Defines the Sequence of Data Elements that specify the criteria relating to call report requests. */

struct TpCallReportRequest

{

TpCallMonitorMode MonitorMode;

TpCallReportType CallReportType;

TpCallAdditionalReportCriteria AdditionalReportCriteria;

};

/* Defines a Numbered Set of Data Elements of TpCallReportRequest. */

typedef sequence <TpCallReportRequest> TpCallReportRequestSet;

const TpInt32 P_CALL_SUPERVISE_TIMEOUT = 1; /* The call supervision timer has expired. */

const TpInt32 P_CALL_SUPERVISE_CALL_ENDED = 2; /* The call has ended, either due to timer expiry or calling or called party release. In case the called party disconnects but a follow-on call can still be made also this indication is used.*/

const TpInt32 P_CALL_SUPERVISE_TONE_APPLIED = 4; /* A warning tone has been applied. */

const TpInt32 P_CALL_SUPERVISE_UI_FINISHED = 8; /* The user interaction has finished */

/* Defines the responses from the call control SCF for calls that are supervised:*/

typedef TpInt32 TpCallSuperviseReport;

const TpInt32 P_CALL_SUPERVISE_RELEASE = 1; /* Release the call when the call supervision timer expires. */

const TpInt32 P_CALL_SUPERVISE_RESPOND = 2; /* Notify the application when the call supervision timer expires. */

const TpInt32 P_CALL_SUPERVISE_APPLY_TONE = 4; /* Send a warning tone to the controlling party when the call supervision timer expires. If call release is requested, then the call will be released following the tone after an administered time period */

/* Defines the following treatment of the call by the call control SCF when the call supervision timer expires.*/

typedef TpInt32 TpCallSuperviseTreatment;

/* Define the possible Exceptions. */

const TpInt32 P_GCCS_SERVICE_INFORMATION_MISSING = 256;

const TpInt32 P_GCCS_SERVICE_FAULT_ENCOUNTERED = 257;

const TpInt32 P_GCCS_UNEXPECTED_SEQUENCE = 258;

const TpInt32 P_GCCS_INVALID_ADDDRESS = 259;

const TpInt32 P_GCCS_INVALID_CRITERIA = 260;

const TpInt32 P_GCCS_INVALID_NETWORK_STATE = 261;

exception TpGCCSException

{

TpInt32 exceptionType;

};

/* The next data type is not used for an SCF implementation based

on this specification: */

typedef TpInt32 TpCallLoadControlIntervalRate;

/* The next data type is not used for an SCF implementation based

on this specification: */

const TpInt32 P_CALL_LOAD_CONTROL_ADMIT_NO_CALLS = 0;

/* The next data type is not used for an SCF implementation based

on this specification: */

enum TpCallLoadControlMechanismType {

P_CALL_LOAD_CONTROL_PER_INTERVAL

};

/* The next data type is not used for an SCF implementation based

on this specification: */

union TpCallLoadControlMechanism switch(TpCallLoadControlMechanismType) {

case P_CALL_LOAD_CONTROL_PER_INTERVAL:

TpCallLoadControlIntervalRate CallLoadControlPerInterval;

};

/* The next data type is not used for an SCF implementation based

on this specification: */

enum TpCallTreatmentType {

P_CALL_TREATMENT_DEFAULT,

P_CALL_TREATMENT_RELEASE,

P_CALL_TREATMENT_SIAR

};

/* The next data type is not used for an SCF implementation based

on this specification: */

union TpCallAdditionalTreatmentInfo switch(TpCallTreatmentType) {

case P_CALL_TREATMENT_SIAR: ui::TpUIInfo InformationToSend;

default: short Dummy;

};

/* The next data type is not used for an SCF implementation based

on this specification: */

struct TpCallTreatment {

TpCallTreatmentType CallTreatmentType;

TpCallReleaseCause ReleaseCause;

TpCallAdditionalTreatmentInfo AdditionalTreatmentInfo;

};

}; // end module cc

}; // end module osa

}; // end module threegpp

}; // end module org

#endif

// END file CC.idl

9.3.2 Generic Call Control IDL

// source file: GCC.idl

// GenericCall Interface description

#ifndef __OSA_CC_GCC_DEFINED

#define __OSA_CC_GCC_DEFINED

#include <CC.idl>

module org {

module threegpp {

module osa {

module cc {

module gcc {

interface IpAppCallControlManager; // forward definition

interface IpAppCall; // forward definition

interface IpCall; // forward definition

/* Sequence of Data Elements that unambiguously specify the Generic Call object */

struct TpCallIdentifier {

IpCall CallReference;

TpSessionID CallSessionID;

};

/* This interface is the SCF manager’ interface for Generic Call Control. */

interface IpCallControlManager : IpService {

/* This method is used to enable call notifications. */

void enableCallNotification (

in IpAppCallControlManager appInterface,

in TpCallEventCriteria eventCriteria,

out TpAssignmentID assignmentID

)

raises (TpGCCSException, TpGeneralException);

/* This method is used by the application to disable call notifications.*/

void disableCallNotification (

in TpAssignmentID assignmentID

)

raises (TpGCCSException, TpGeneralException);

void changeCallNotification (

in TpAssignmentID assignmentID,

in TpCallEventCriteria eventCriteria

)

raises (TpGCCSException, TpGeneralException);

void getCriteria (

out TpCallEventCriteriaResultSet eventCriteria

)

raises (TpGCCSException, TpGeneralException);

/* The next operation is not supported for Release 99 and must

return the exception “Method not supported” when invoked on a SCF

implementation based on this specification: */

void createCall (

in IpAppCall appCall,

out TpCallIdentifier callReference

)

raises (TpGCCSException,TpGeneralException);

/* The next operation is not supported for Release 99 and must

return the exception “Method not supported” when invoked on a SCF

implementation based on this specification: */

void setCallLoadControl (

in TpDuration duration,

in TpCallLoadControlMechanism mechanism,

in TpCallTreatment treatment,

in TpAddressRange addressRange,

out TpAssignmentID assignmentID

)

raises (TpGCCSException, TpGeneralException);

};

/* This interface provides the means to control a simple call. */

interface IpCall : IpService {

/* This method requests routing of the call to the destination party.*/

void routeReq (

in TpSessionID callSessionID,

in TpCallReportRequestSet responseRequested,

in TpAddress targetAddress,

in TpAddress originatingAddress,

in TpAddress originalDestinationAddress,

in TpAddress redirectingAddress,

in TpCallAppInfoSet appInfo,

out TpSessionID callLegSessionID

)

raises (TpGCCSException, TpGeneralException);

/* This method requests the release of the call and associated objects.*/

void release (

in TpSessionID callSessionID,

in TpCallReleaseCause cause

)

raises (TpGCCSException, TpGeneralException);

/* This method requests that the relationship between the application and

the call and associated objects be de-assigned. */

void deassignCall (

in TpSessionID callSessionID

)

raises (TpGCCSException, TpGeneralException);

/* This method requests information associated with the call.*/

void getCallInfoReq (

in TpSessionID callSessionID,

in TpCallInfoType callInfoRequested

)

raises (TpGCCSException, TpGeneralException);

/* Set an operator specific charge plan for the call. */

void setCallChargePlan (

in TpSessionID callSessionID,

in TpCallChargePlan callChargePlan

)

raises (TpGCCSException, TpGeneralException);

/* The application calls this method to supervise a call. */

void superviseCallReq (

in TpSessionID callSessionID,

in TpDuration time,

in TpCallSuperviseTreatment treatment

)

raises (TpGCCSException, TpGeneralException);

void setAdviceOfCharge(

in TpSessionID callSessionID,

in TpAoCInfo aOCInfo,

in TpDuration tariffSwitch

)

raises (TpGCCSException, TpGeneralException);

/* The next operation is not supported for Release 99 and must

return the exception “Method not supported” when invoked on a SCF

implementation based on this specification: */

void getMoreDialledDigitsReq (

in TpSessionID callSessionID,

in TpInt32 length

)

raises (TpGeneralException, TpGCCSException);

};

/* The generic call control manager application interface provides the

application call control management functions to the generic call control

SCF. */

interface IpAppCallControlManager : IpOsa {

void callAborted (

in TpSessionID callReference

)

raises (TpGCCSException, TpGeneralException);

/* This method notifies the application of the arrival of a call-related event. */

void callEventNotify (

in TpCallIdentifier callReference,

in TpCallEventInfo eventInfo,

in TpAssignmentID assignmentID,

out IpAppCall appInterface

)

raises (TpGCCSException, TpGeneralException);

/* This method indicates to the application that all event notifications

have been terminated .*/

void callNotificationInterrupted ()

raises (TpGCCSException, TpGeneralException);

void callNotificationContinued ()

raises (TpGCCSException, TpGeneralException);

/* The next operation is not supported for Release 99 and must

return the exception “Method not supported” when invoked on a SCF

implementation based on this specification: */

void callOverloadEncountered (

in TpAssignmentID assignmentID

)

raises (TpGeneralException,TpGCCSException);

/* The next operation is not supported for Release 99 and must

return the exception “Method not supported” when invoked on a SCF

implementation based on this specification: */

void callOverloadCeased (

in TpAssignmentID assignmentID

)

raises (TpGeneralException,TpGCCSException);

};

/* The application side of the simple call interface is used to handle call

request responses and state reports. */

interface IpAppCall : IpOsa {

/* This method indicates that the request to route the call to the

destination was successful.*/

void routeRes (

in TpSessionID callSessionID,

in TpCallReport eventReport,

in TpSessionID callLegSessionID

)

raises (TpGCCSException, TpGeneralException);

/* This method indicates that the request to route the call to the

destination party was unsuccessful. */

void routeErr (

in TpSessionID callSessionID,

in TpCallError errorIndication,

in TpSessionID callLegSessionID

)

raises (TpGCCSException, TpGeneralException);

/* This method reports all necessary information requested by the

application, for example to calculate charging.*/

void getCallInfoRes (

in TpSessionID callSessionID,

in TpCallInfoReport callInfoReport

)

raises (TpGCCSException, TpGeneralException);

/* This asynchronous method reports that the original request was erroneous,

or resulted in an error condition.*/

void getCallInfoErr (

in TpSessionID callSessionID,

in TpCallError errorIndication

)

raises (TpGCCSException, TpGeneralException);

/* This asynchronous method reports a call supervision event to the application.*/

void superviseCallRes (

in TpSessionID callSessionID,

in TpCallSuperviseReport report,

in TpDuration usedTime

)

raises (TpGCCSException, TpGeneralException);

/* This asynchronous method reports a call supervision error to the application.*/

void superviseCallErr (

in TpSessionID callSessionID,

in TpCallError errorIndication

)

raises (TpGCCSException, TpGeneralException);

/* This method indicates to the application that a fault in the network has

been detected.*/

void callFaultDetected (

in TpSessionID callSessionID,

in TpCallFault fault

)

raises (TpGCCSException, TpGeneralException);

void callEnded (

in TpSessionID callSessionID,

in TpCallEndedReport report

)

raises (TpGCCSException, TpGeneralException);

/* The next operation is not supported for Release 99 and must

return the exception “Method not supported” when invoked on a SCF

implementation based on this specification: */

void getMoreDialledDigitsRes (

in TpSessionID callSessionID,

in TpString digits

)

raises (TpGeneralException,TpGCCSException);

/* The next operation is not supported for Release 99 and must

return the exception “Method not supported” when invoked on a SCF

implementation based on this specification: */

void getMoreDialledDigitsErr (

in TpSessionID callSessionID,

in TpCallError errorIndication

)

raises (TpGeneralException,TpGCCSException);

};

}; // end module gcc

}; // end module cc

}; // end module osa

}; // end module threegpp

}; // end module org

#endif

// END file GCC.idl

9.3.3 Enhanced Call Control IDL

The IDL in this section is only supplied in order to make the User Interaction IDL compile.

With the createUICall() method on the UIManager object it is possible to associate the UICall object to a Call object as well as a CallLeg object. The CallLeg object is not used in this specification. However the IDL for this interface has to be supplied otherwise the User Interaction IDL will not compile.

// source file: ECC.idl

#ifndef __OSA_CC_ECC_DEFINED

#define __OSA_CC_ECC_DEFINED

#include <GCC.idl>

module org {

module threegpp {

module osa {

module cc {

module ecc {

typedef TpInt32 TpMediaType;

const TpInt32 P_AUDIO = 1;

const TpInt32 P_VIDEO = 2;

const TpInt32 P_DATA = 4;

typedef TpInt32 TpAudioCapabilitiesType;

typedef TpInt32 TpVideoCapabilitiesType;

typedef TpInt32 TpDataCapabilities;

union TpChannelDataTypeRequest switch(TpMediaType) {

case P_DATA: TpDataCapabilities Data;

case P_VIDEO: TpVideoCapabilitiesType Video;

case P_AUDIO: TpAudioCapabilitiesType Audio;

};

typedef TpChannelDataTypeRequest TpChannelDataType;

enum TpChannelDirection {

P_INCOMING,

P_OUTGOING

};

struct TpChannelRequest {

TpChannelDataTypeRequest DataTypeRequest;

TpChannelDirection Direction;

};

typedef sequence <TpChannelRequest> TpChannelRequestSet;

enum TpCallLegType {

P_CALL_LEG_TYPE_UNDEFINED,

P_CALL_LEG_TYPE_CONTROLLING,

P_CALL_LEG_TYPE_PASSIVE

};

enum TpCallLegInfoType {

P_CALL_LEG_INFO_UNDEFINED,

P_CALL_LEG_INFO_ADDRESS,

P_CALL_LEG_INFO_RELEASE_CAUSE,

P_CALL_LEG_INFO_APPINFO,

P_CALL_LEG_INFO_TIMES

};

interface IpMMChannel : IpService {

void close (

in TpSessionID channelSessionID

)

raises (TpGeneralException,TpGCCSException);

};

struct TpChannel {

TpChannelDirection Direction;

IpMMChannel Channel;

TpChannelDataType DataType;

TpInt32 ChannelNumber;

};

typedef sequence <TpChannel> TpChannelSet;

interface IpCallLeg : IpService {

void routeCallLegToOrigination (

in TpSessionID callLegSessionID,

in TpAddress targetAddress,

in TpAddress originatingAddress,

in TpAddress originalCalledAddress,

in TpAddress redirectingAddress,

in TpCallAppInfoSet appInfo

)

raises (TpGeneralException,TpGCCSException);

void routeCallLegToDestination (

in TpSessionID callLegSessionID,

in TpAddress targetAddress,

in TpAddress originatingAddress,

in TpAddress originalCalledAddress,

in TpAddress redirectingAddress,

in TpCallAppInfoSet appInfo

)

raises (TpGeneralException,TpGCCSException);

void eventReportReq (

in TpSessionID callLegSessionID,

in TpCallReportRequestSet eventReportsRequested

)

raises (TpGeneralException,TpGCCSException);

void release (

in TpSessionID callLegSessionID,

in TpCallReleaseCause cause

)

raises (TpGeneralException,TpGCCSException);

void getInfoReq (

in TpSessionID callLegSessionID,

in TpCallLegInfoType callLegInfoRequested

)

raises (TpGeneralException,TpGCCSException);

void getType (

in TpSessionID callLegSessionID,

out TpCallLegType callLegType

)

raises (TpGeneralException,TpGCCSException);

void getCall (

in TpSessionID callLegSessionID,

out org::threegpp::osa::cc::gcc::TpCallIdentifier callReference

)

raises (TpGeneralException,TpGCCSException);

void mediaChannelAllow (

in TpSessionID callLegSessionID,

in TpSessionIDSet channelList

)

raises (TpGeneralException,TpGCCSException);

void getMediaChannels (

in TpSessionID callLegSessionID,

out TpChannelSet channels

)

raises (TpGeneralException,TpGCCSException);

void mediaChannelMonitorReq (

in TpSessionID callLegSessionID,

in TpChannelRequestSet channelEventCriteria,

in TpCallMonitorMode monitorMode

)

raises (TpGeneralException,TpGCCSException);

};

struct TpCallLegIdentifier {

TpSessionID CallLegSessionID;

IpCallLeg CallLegReference;

};

}; // end module ecc

}; // end module cc

}; // end module osa

}; // end module threegpp

}; // end module org

#endif

// END file ECC.idl

9.4 User Interaction IDL

9.4.1 Common data types for User Interaction

// source file: UI.idl

// User Interaction data description

#ifndef __OSA_UI_DEFINED

#define __OSA_UI_DEFINED

#include <OSA.idl>

module org {

module threegpp {

module osa {

module ui {

/* Defines the additional properties for the collection of information */

struct TpUICollectCriteria {

TpInt32 MinLength; /* minimum number of characters to collect */

TpInt32 MaxLength; /* maxmum number of characters to collect */

TpString EndSequence; /* character(s) which terminate an input of variable length. */

TpDuration StartTimeout; /* defines a duration (in seconds) */

TpDuration InterCharTimeout; /* value for the inter-character time-out timer. */

};

/* Defines the UI call error codes. */

enum TpUIError {

P_UI_ERROR_UNDEFINED, /* Undefined error */

P_UI_ERROR_ILLEGAL_ID, /* The information id specified is invalid */

P_UI_ERROR_ID_NOT_FOUND, /* Information id is not known to the the User Interaction SCFs */

P_UI_ERROR_RESOURCE_UNAVAILABLE, /* Resources used by the User Interaction SCFs are unavailable. */

P_UI_ERROR_ILLEGAL_RANGE, /* The values for manimum and maximum collection length are out of range */

P_UI_ERROR_IMPROPER_CALLER_RESPONSE, /* Improper user response */

P_UI_ERROR_ABANDON, /* Specified leg is disconnected before the send information completed */

P_UI_ERROR_NO_OPERATION_ACTIVE, /* No active user interaction for the specified leg. */

P_UI_ERROR_NO_SPACE_AVAILABLE /* There is no more storage capacity to record the message.*/

};

/* Defines the type of the dataString parameter in the method userInteractionEventNotify */

enum TpUIEventInfoDataType {

P_UI_EVENT_DATA_TYPE_UNDEFINED, /* Undefined */

P_UI_EVENT_DATA_TYPE_UNSPECIFIED, /* Unspecified data */

P_UI_EVENT_DATA_TYPE_TEXT, /* Text */

P_UI_EVENT_DATA_TYPE_USSD_DATA /* USSD data starting with coding scheme */

};

/* Defines the Sequence of Data Elements that specify the additional criteria for receiving a UI notification */

struct TpUIEventCriteria {

TpAddressRange OriginatingAddress; /* Address of the end-user for which notification shall be handled */

TpAddressRange DestinationAddress;

TpString ServiceCode; /* 2 digit code indicating the UI to be triggered. */

};

/* Defines the Sequence of Data Elements that specify a UI notification */

struct TpUIEventInfo {

TpAddress OriginatingAddress; /* Address of the end-user for which notification shall be handled */

TpAddress DestinationAddress;

TpString ServiceCode; /* 2 digit code indicating the UI to be triggered. */

TpUIEventInfoDataType DataTypeIndication;

TpString DataString;

};

/* Defines the cause of the UI fault detected. */

enum TpUIFault {

P_UI_FAULT_UNDEFINED, /* Undefined */

P_UI_CALL_DEASSIGNED /* The related Call object has been deassigned. */

};

/* Defines the type of information send to the end-user */

enum TpUIInfoType {

P_UI_INFO_ID, /* The information consists of an ID */

P_UI_INFO_DATA, /* The information consists of a data string */

P_UI_INFO_ADDRESS /* The information consists of a URL. */

};

/* Defines the Tagged Choice of Data Elements that specifies the information to be send to a end-user. */

union TpUIInfo switch(TpUIInfoType) {

case P_UI_INFO_ID: TpInt32 InfoID; /*Defines the ID of the user information script or stream to send to an end-user.*/

case P_UI_INFO_DATA: TpString InfoData; /*Defines the data to be sent to an end-user’s terminal.*/

case P_UI_INFO_ADDRESS: TpURL InfoAddress; /*Defines the URL of the text or stream to be sent to an end-user’s terminal*/

};

/* Defines the criteria for recording of messages */

struct TpUIMessageCriteria {

TpString EndSequence; /* Defines the character(s) which terminate an input of variable length. */

TpDuration MaxMessageTime; /* Specifies the maximum allowed duration in seconds. */

TpInt32 MaxMessageSize; /* Specifies the maximum allowed size in bytes of the message. */

};

/* Defines the UI call reports if a response was requested. */

enum TpUIReport {

P_UI_REPORT_UNDEFINED, /* Undefined report */

P_UI_REPORT_ANNOUNCEMENT_ENDED, /* Confirmation that the announcement has ended */

P_UI_REPORT_LEGAL_INPUT, /* Information collected., meeting the specified criteria. */

P_UI_REPORT_NO_INPUT, /* User immediately entered the delimiter character. No valid information has been returned */

P_UI_REPORT_TIMEOUT, /* User did not input any response before the input timeout expired */

P_UI_REPORT_MESSAGE_STORED, /* A message has been stored successfully */

P_UI_REPORT_MESSAGE_NOT_STORED /* The message has not been stored successfully */

};

/* Defines the situations for which a response is expected following the user interaction. */

const TpInt32 P_UI_RESPONSE_REQUIRED = 1; /* A response must be sent when the request has completed. */

const TpInt32 P_UI_LAST_ANNOUNCEMENT_IN_A_ROW = 2; /* This is the final announcement within a sequence. */

const TpInt32 P_UI_FINAL_REQUEST = 4; /* This is the final request. */

typedef TpInt32 TpUIResponseRequest; /* Defines the situations for which a response is expected following the user interaction. */

/* Defines the type of the variable parts in the information to send to the user. */

enum TpUIVariablePartType {

P_UI_VARIABLE_PART_INT, /* Variable part is of type integer */

P_UI_VARIABLE_PART_ADDRESS, /* Variable part is of type address */

P_UI_VARIABLE_PART_TIME, /* Variable part is of type time */

P_UI_VARIABLE_PART_DATE, /* Variable part is of type date */

P_UI_VARIABLE_PART_PRICE /* Variable part is of type price */

};

/* Defines the Tagged Choice of Data Elements that specify the variable parts in the information to send to the user. */

union TpUIVariableInfo switch(TpUIVariablePartType) {

case P_UI_VARIABLE_PART_INT: TpInt32 VariablePartInteger;

case P_UI_VARIABLE_PART_ADDRESS: TpString VariablePartAddress;

case P_UI_VARIABLE_PART_TIME: TpTime VariablePartTime;

case P_UI_VARIABLE_PART_DATE: TpDate VariablePartDate;

case P_UI_VARIABLE_PART_PRICE: TpPrice VariablePartPrice;

};

/* Defines a Numbered Set of Data Elements of TpUIVariableInfo. */

typedef sequence <TpUIVariableInfo> TpUIVariableInfoSet;

/* Define the possible Exceptions. */

exception TpGUISException {

TpInt32 exceptionType;

};

const TpInt32 P_GUIS_INVALID_CRITERIA = 768; /* Invalid criteria specified */

const TpInt32 P_GUIS_ILLEGAL_ID = 769; /* Information id specified is invalid */

const TpInt32 P_GUIS_ID_NOT_FOUND = 770; /* Information id is not known to the User Interaction Service */

const TpInt32 P_GUIS_ILLEGAL_RANGE = 771; /* The values for minimum and maximum collection length are out of range */

const TpInt32 P_GUIS_INVALID_COLLECTION_CRITERIA = 772; /* Invalid collection criteria specified */

const TpInt32 P_GUIS_INVALID_NETWORK_STATE = 773; /* Although the sequence of method calls is allowed by the gateway, the underlying protocol can not support it. */

const TpInt32 P_GUIS_UNEXPECTED_SEQUENCE = 774; /* Although the sequence of method calls is allowed by the gateway, the underlying protocol can not support it. */

}; // end module ui

}; // end module osa

}; // end module threegpp

}; // end module org

#endif

// END file UI.idl

9.4.2 Generic User Interaction IDL

// source file: GUI.idl

// GUIS Interface description

#ifndef __OSA_UI_GUI_DEFINED

#define __OSA_UI_GUI_DEFINED

#include <UI.idl>

#include <ECC.idl>

module org {

module threegpp {

module osa {

module ui {

module gui {

interface IpAppUIManager; // forward definition;

interface IpAppUI; // forward definition;

interface IpAppUICall; // forward definition;

/* The Generic User Interaction SCF Interface provides functions to send

information to, or gather information from the user. */

interface IpUI : IpService {

/* This method plays an announcement or sends other information to the user.*/

void sendInfoReq (

in TpSessionID userInteractionSessionID,

in TpUIInfo info,

in TpUIVariableInfoSet variableInfo,

in TpInt32 repeatIndicator,

in TpUIResponseRequest responseRequested,

out TpAssignmentID assignmentID

)

raises (TpGUISException, TpGeneralException);

/* This method plays an announcement or sends other information to the user

and collects some information from the user. */

void sendInfoAndCollectReq (

in TpSessionID userInteractionSessionID,

in TpUIInfo info,

in TpUIVariableInfoSet variableInfo,

in TpUICollectCriteria criteria,

in TpUIResponseRequest responseRequested,

out TpAssignmentID assignmentID

)

raises (TpGUISException, TpGeneralException);

/* This method requests that the relationship between the application and

the user interaction object be released. */

void release (

in TpSessionID userInteractionSessionID

)

raises (TpGUISException, TpGeneralException);

};

/* Defines the Sequence of Data Elements that unambiguously specify the UI object */

struct TpUIIdentifier {

TpSessionID UserInteractionSessionID;

IpUI UIRef;

};

/* The Call User Interaction Service Interface provides functions to send

information to, or gather information from, the user. */

interface IpUICall : IpUI {

/* This asynchronous method aborts the specified user interaction operation. */

void abortActionReq (

in TpSessionID userInteractionSessionID,

in TpAssignmentID assignmentID

)

raises (TpGUISException, TpGeneralException);

/* The next operation is not supported for Release 99 and must

return the exception “Method not supported” when invoked on a SCF

implementation based on this specification: */

void recordMessageReq (

in TpSessionID userInteractionSessionID,

in TpUIInfo info,

in TpUIMessageCriteria criteria,

out TpAssignmentID assignmentID

)

raises (TpGUISException, TpGeneralException);

};

/* Defines the Sequence of Data Elements that unambiguously specify the UICall object. */

struct TpUICallIdentifier {

IpUICall UICallRef;

TpSessionID UserInteractionSessionID;

};

/* This interface is the ‘SCF manager’ interface for the Generic User Interaction SCF. */

interface IpUIManager : IpService {

/* This method is used to create a new user interaction object for non-call related purposes */

void createUI (

in IpAppUI appUI,

in TpAddress userAddress,

out TpUIIdentifier userInteraction

)

raises (TpGUISException, TpGeneralException);

/* This method is used to create a new user interaction object for call related purposes. */

void createUICall (

in IpAppUICall appUI,

in cc::gcc::TpCallIdentifier callIdentifier,

in cc::ecc::TpCallLegIdentifier callLegIdentifier,

out TpUICallIdentifier userInteraction

)

raises (TpGUISException, TpGeneralException);

/* This method is used to enable the reception of user initiated user interaction. */

void enableUINotification (

in IpAppUIManager appInterface,

in TpUIEventCriteria eventCriteria,

out TpAssignmentID assignmentID

)

raises (TpGUISException, TpGeneralException);

/* This method is used by the application to disable UI notifications. */

void disableUINotification (

in TpAssignmentID assignmentID

)

raises (TpGUISException, TpGeneralException);

};

/* The Generic User Interaction SCF manager application interface provides

the application call management functions to the Generic User Interaction SCF. */

interface IpAppUIManager : IpOsa {

/* This method indicates to the application that the User Interaction SCF

instance has terminated or closed abnormally. */

void userInteractionAborted (

in TpUIIdentifier userInteraction

)

raises (TpGUISException, TpGeneralException);

/* This method notifies the application of an user initiated request for user interaction. */

void userInteractionEventNotify (

in TpUIIdentifier ui,

in TpUIEventInfo eventInfo,

in TpAssignmentID assignmentID,

out IpAppUI appInterface

)

raises (TpGUISException, TpGeneralException);

void userInteractionNotificationInterrupted ()

raises (TpGUISException, TpGeneralException);

void userInteractionNotificationContinued ()

raises (TpGUISException, TpGeneralException);

};

/* The User Interaction Application Interface is used to handle generic user

interaction request responses and reports. */

interface IpAppUI : IpOsa {

/* This method informs the application about the start or the completion of a sendInfoCallReq(). */

void sendInfoRes (

in TpSessionID userInteractionSessionID,

in TpAssignmentID assignmentID,

in TpUIReport response

)

raises (TpGUISException, TpGeneralException);

/* This asynchronous method indicates that the request to send information was unsuccessful. */

void sendInfoErr (

in TpSessionID userInteractionSessionID,

in TpAssignmentID assignmentID,

in TpUIError error

)

raises (TpGUISException, TpGeneralException);

/* This asynchronous method returns the information collected to the application. */

void sendInfoAndCollectRes (

in TpSessionID userInteractionSessionID,

in TpAssignmentID assignmentID,

in TpUIReport response,

in TpString info

)

raises (TpGUISException, TpGeneralException);

/* This asynchronous method indicates that the request to send information

and collect a response was unsuccessful. */

void sendInfoAndCollectErr (

in TpSessionID userInteractionSessionID,

in TpAssignmentID assignmentID,

in TpUIError error

)

raises (TpGUISException, TpGeneralException);

/* This method indicates to the application that a fault has been detected in the user interaction. */

void userInteractionFaultDetected (

in TpSessionID userInteractionSessionID,

in TpUIFault fault

)

raises (TpGUISException, TpGeneralException);

};

/* The Call User Interaction Application Interface is used to handle call user

interaction request responses and reports. */

interface IpAppUICall : IpAppUI {

/* This method confirms that the request to abort a user interaction operation on a call was successful. */

void abortActionRes (

in TpSessionID userInteractionSessionID,

in TpAssignmentID assignmentID

)

raises (TpGUISException, TpGeneralException);

/* This asynchronous method indicates that the request to abort a user interaction

operation on a call resulted in an error.*/

void abortActionErr (

in TpSessionID userInteractionSessionID,

in TpAssignmentID assignmentID,

in TpUIError error

)

raises (TpGUISException, TpGeneralException);

/* The next operation is not supported for Release 99 and must

return the exception “Method not supported” when invoked on a SCF

implementation based on this specification: */

void recordMessageRes (

in TpSessionID userInteractionSessionID,

in TpAssignmentID assignmentID,

in TpUIReport response,

in TpInt32 messageID

)

raises (TpGUISException, TpGeneralException);

/* The next operation is not supported for Release 99 and must

return the exception “Method not supported” when invoked on a SCF

implementation based on this specification: */

void recordMessageErr (

in TpSessionID userInteractionSessionID,

in TpAssignmentID assignmentID,

in TpUIError error

)

raises (TpGUISException, TpGeneralException);

};

}; // end module gui

}; // end module ui

}; // end module osa

}; // end module threegpp

}; // end module org

#endif

// END file GUI.idl

9.5 Data Session Control

// OSA data session control

#ifndef __OSA_DSC_DEFINED

#define __OSA_DSC_DEFINED

#include "osa.idl"

module org

{

module threegpp

{

module osa

{

// data session control

module dsc

{

interface IpDataSessionControlManager; // forward definition

interface IpDataSession; // forward definition

interface IpAppDataSessionControlManager; // forward definition

interface IpAppDataSession; // forward definition

const TpInt32 P_EVENT_NAME_UNDEFINED = 0; // Undefined

const TpInt32 P_EVENT_DSCS_ESTABLISHED_ = 1; // Data Session established

typedef TpInt32 TpDataSessionEventName; /*Defines the names of event being notified. */

enum TpDataSessionChargeOrderCategory

{

P_DATA_SESSION_CHARGE_PER_VOLUME,

P_DATA_SESSION_CHARGE_NETWORK

};

struct TpChargePerVolume

{

TpInt32 InitialCharge;

TpInt32 CurrentChargePerKilobyte;

TpInt32 NextChargePerKilobyte;

};

union TpDataSessionChargeOrder switch(TpDataSessionChargeOrderCategory)

{

case P_DATA_SESSION_CHARGE_PER_VOLUME: TpChargePerVolume ChargePerVolume;

case P_DATA_SESSION_CHARGE_NETWORK: TpString NetworkCharge;

};

struct TpDataSessionChargePlan

{

TpDataSessionChargeOrder ChargeOrderType;

TpString Currency;

TpString AdditionalInfo;

};

struct TpDataSessionEventCriteria

{

TpAddressRange DestinationAddress; /*Destination address range*/

TpAddressRange OriginationAddress; /*Origination address range */

TpDataSessionEventName DataSessionEventName; /*Name of the event(s) */

};

/* Defines the mode that the data session will monitor for events, or the mode that the data session is in following a detected event. */

enum TpDataSessionMonitorMode

{

P_DATA_SESSION_MONITOR_MODE_INTERRUPT, /* The data session event is intercepted by the data session control SCF and data session establishment is interrupted. The application is notified of the event and data session establishment resumes following an appropriate API call or network event (such as a data session release) */

P_DATA_SESSION_MONITOR_MODE_NOTIFY, /* The data session event is detected by the data session control SCF but not intercepted. The application is notified of the event data session establishment continues */

P_DATA_SESSION_MONITOR_MODE_DO_NOT_MONITOR /* Do not monitor for the event */

};

struct TpDataSessionEventInfo

{

TpAddress DestinationAddress;

TpAddress OriginatingAddress;

TpDataSessionEventName DataSessionEventName;

TpDataSessionMonitorMode MonitorMode;

};

/* Defines the Sequence of Data Elements that specify the cause of the release of a call.*/

struct TpDataSessionReleaseCause

{

TpInt32 Value;

TpInt32 Location;

};

/* Defines a specific data session error. */

enum TpDataSessionErrorType

{

P_DATA_SESSION_ERROR_UNDEFINED, /* Undefined */

P_DATA_SESSION_ERROR_INVALID_ADDRESS, /* The operation failed because an invalid address was given */

P_DATA_SESSION_ERROR_INVALID_STATE /* The data session was not in a valid state for the requested operation */

};

/* Defines the Tagged Choice of Data Elements that specify additional data session error and data session error specific information. */

union TpDataSessionAdditionalErrorInfo switch(TpDataSessionErrorType)

{

case P_DATA_SESSION_ERROR_INVALID_ADDRESS: TpAddressError DataSessionErrorInvalidAddress;

};

/* Defines the Sequence of Data Elements that specify the additional information relating to an undefined data session error. */

struct TpDataSessionError

{

TpDataSessionAdditionalErrorInfo AdditionalErrorInfo;

TpDataSessionErrorType ErrorType;

TpDateAndTime ErrorTime;

};

/* Defines the cause of the Data Session fault detected. */

enum TpDataSessionFault

{

P_DATA_SESSION_FAULT_UNDEFINED, /* Undefined */

P_DATA_SESSION_FAULT_USER_ABORTED, /* User has finalised the data session before any message could be sent by the application. */

P_DATA_SESSION_TIMEOUT_ON_RELEASE, /* Final report has been sent to the application, but the application did not explicitly release data session object, within a specified time. */

P_DATA_SESSION_TIMEOUT_ON_INTERRUPT /* Application did not instruct the gateway how to handle the data session within a specified time, after the gateway reported an event that was requested by the application in interrupt mode.*/

};

/* Defines a specific data session event report type. */

enum TpDataSessionReportType

{

P_DATA_SESSION_REPORT_UNDEFINED, /* Undefined */

P_DATA_SESSION_REPORT_CONNECTED, /* Data session established*/

P_DATA_SESSION_REPORT_DISCONNECT /* data session disconnect requested by data session party */

};

/* Defines the Tagged Choice of Data Elements that specify additional data session report information. */

union TpDataSessionAdditionalReportInfo switch(TpDataSessionReportType)

{

case P_DATA_SESSION_REPORT_DISCONNECT: TpDataSessionReleaseCause DataSessionDisconnect;

};

struct TpDataSessionReport

{

TpDataSessionMonitorMode MonitorMode;

TpDateAndTime DataSessionEventTime;

TpDataSessionReportType DataSessionReportType;

TpDataSessionAdditionalReportInfo AdditionalReportInfo;

};

/* Defines the Sequence of Data Elements that specify the criteria relating to Data Session report requests. */

struct TpDataSessionReportRequest

{

TpDataSessionMonitorMode MonitorMode;

TpDataSessionReportType DataSessionReportType;

};

/* Defines a Numbered Set of Data Elements of TpDataSessionReportRequest. */

typedef sequence <TpDataSessionReportRequest> TpDataSessionReportRequestSet;

const TpInt32 P_DATA_SESSION_SUPERVISE_VOLUME_REACHED = 1; /* The Data Session supervision volume has been reached. */

const TpInt32 P_DATA_SESSION_SUPERVISE_DATA_SESSION_ENDED = 2; /* The data session has ended, either due to reach of maximum volume or calling or called party release. */

const TpInt32 P_DATA_SESSION_SUPERVISE_MESSAGE_SENT = 4; /* A warning message has been sent. */

/* Defines the responses from the data session control SCF for data sessions that are supervised:*/

typedef TpInt32 TpDataSessionSuperviseReport;

const TpInt32 P_DATA_SESSION_SUPERVISE_RELEASE = 1; /* Release the Data Session when the Data Session supervision volume has been reached. */

const TpInt32 P_DATA_SESSION_SUPERVISE_RESPOND = 2; /* Notify the application when the data session supervision volume has been reached. */

const TpInt32 P_DATA_SESSION_SUPERVISE_INFORM = 4; /* Send a warning message to the originating party when the maximum volume is reached. If data session release is requested, then the data session will be released following the message after an administered time period */

/* Defines the following treatment of the data session by the data session control SCF when the maximum volume has been reached.*/

typedef TpInt32 TpDataSessionSuperviseTreatment;

/* Defines the Sequence of Data Elements that specify the amount of volume that is allowed to be transmitted for the specific connection. */

struct TpDataSessionSuperviseVolume {

TpInt32 VolumeQuantity; /* Qantity of the granted volume that can be transmitted for the specific connection. */

TpInt32 VolumeUnit; /* Unit of the granted volume that can be transmitted for the specific connection. */

};

/* Define the possible Exceptions. */

const TpInt32 P_DSCS_SERVICE_INFORMATION_MISSING = 1024;

const TpInt32 P_DSCS_SERVICE_FAULT_ENCOUNTERED = 1025;

const TpInt32 P_DSCS_UNEXPECTED_SEQUENCE = 1026;

const TpInt32 P_DSCS_INVALID_ADDDRESS = 1027;

const TpInt32 P_DSCS_INVALID_STATE = 1028;

const TpInt32 P_DSCS_INVALID_CRITERIA = 1029;

const TpInt32 P_DSCS_INVALID_NETWORK_STATE = 1030;

exception TpDSCSException

{

TpInt32 exceptionType;

};

/* Sequence of Data Elements that unambiguously specify the Data Session object */

struct TpDataSessionIdentifier

{

IpDataSession DataSessionReference;

TpSessionID DataSessionSessionID;

};

/* This interface is the SCF manager’ interface for Data Session Control. */

interface IpDataSessionControlManager : IpService

{

/* This method is used to enable data session notifications. */

void enableDataSessionNotification (

in IpAppDataSessionControlManager appInterface,

in TpDataSessionEventCriteria eventCriteria,

out TpAssignmentID assignmentID)

raises (TpDSCSException, TpGeneralException);

/* This method is used by the application to disable data session notifications.*/

void disableDataSessionNotification

(

in TpAssignmentID assignmentID)

raises (TpDSCSException, TpGeneralException);

};

/* This interface provides the means to control a data session. */

interface IpDataSession : IpService

{

/* This method requests connection of the data session to the destination party.*/

void connectReq (

in TpSessionID dataSessionID,

in TpDataSessionReportRequestSet responseRequested,

in TpAddress targetAddress,

out TpAssignmentID assignmentID)

raises (TpDSCSException, TpGeneralException);

/* This method requests the release of the data session and associated objects.*/

void release (

in TpSessionID dataSessionID,

in TpDataSessionReleaseCause cause)

raises (TpDSCSException, TpGeneralException);

/* The application calls this method to supervise a data session. */

void superviseDataSessionReq (

in TpSessionID dataSessionID,

in TpDataSessionSuperviseTreatment treatment,

in TpDataSessionSuperviseVolume bytes)

raises (TpDSCSException, TpGeneralException);

/* The application calls this method to set the charge plan */

void setDataSessionChargePlan (

in TpSessionID dataSessionID,

in TpDataSessionChargePlan dataSessionChargePlan)

raises (TpDSCSException, TpGeneralException);

/* The application calls this method to send advice of charge information */

void setAdviceOfCharge (

in TpSessionID dataSessionID,

in TpAoCInfo aoCInfo,

in TpDuration tariffSwitch)

raises (TpDSCSException, TpGeneralException);

};

/* The data session control manager application interface provides the

application data session control management functions to the data session control

SCF. */

interface IpAppDataSessionControlManager : IpOsa

{

void dataSessionAborted (

in TpSessionID dataSessionReference)

raises (TpDSCSException, TpGeneralException);

/* This method notifies the application of the arrival of a data session-related event. */

void dataSessionEventNotify (

in TpDataSessionIdentifier dataSessionReference,

in TpDataSessionEventInfo eventInfo,

in TpAssignmentID assignmentID,

out IpAppDataSession appInterface)

raises (TpDSCSException, TpGeneralException);

/* This method indicates to the application that all event notifications

are resumed.*/

void dataSessionNotificationContinued()

raises (TpDSCSException, TpGeneralException);

/* This method indicates to the application that all event notifications

are temporarely iterrupted.*/

void dataSessionNotificationInterrupted()

raises (TpDSCSException, TpGeneralException);

};

/* The application side of the data session interface is used to handle data session

request responses and state reports. */

interface IpAppDataSession : IpOsa

{

/* This method indicates that the request to route the data session to the

destination was successful.*/

void connectRes (

in TpSessionID dataSessionSessionID,

in TpDataSessionReport eventReport,

in TpAssignmentID assignmentID)

raises (TpDSCSException, TpGeneralException);

/* This method indicates that the request to connect the data session to the

destination party was unsuccessful. */

void connectErr (

in TpSessionID dataSessionSessionID,

in TpDataSessionError errorIndication,

in TpAssignmentID assignmentID)

raises (TpDSCSException, TpGeneralException);

/* This asynchronous method reports a data session supervision event to the application.*/

void superviseDataSessionRes (

in TpSessionID dataSessionSessionID,

in TpDataSessionSuperviseReport report,

in TpDataSessionSuperviseVolume usedVolume)

raises (TpDSCSException, TpGeneralException);

/* This asynchronous method reports a data session supervision error to the application.*/

void superviseDataSessionErr (

in TpSessionID dataSessionSessionID,

in TpDataSessionError errorIndication)

raises (TpDSCSException, TpGeneralException);

/* This method indicates to the application that a fault in the network has

been detected.*/

void dataSessionFaultDetected (

in TpSessionID dataSessionSessionID,

in TpDataSessionFault fault)

raises (TpDSCSException, TpGeneralException);

};

}; // end module dsc

///////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////

}; // osa

}; // threegpp

};

#endif

9.6 Network User Location and User Status IDL

9.6.1 Common definitions for Network User Location and User Status: MM.idl

#include <OSA.idl>

module org {

module threegpp {

module osa {

module mm {

// Defines the type of uncertainty shape.

enum TpLocationUncertaintyShape {

P_M_SHAPE_NONE, // No uncertainty shape present.

P_M_SHAPE_CIRCLE, // Uncertainty shape is a circle.

P_M_SHAPEa_CIRCLE_SECTOR, // Uncertainty shape is a circle sector.

P_M_SHAPE_CIRCLE_ARC_STRIPE, // Uncertainty shape is a circle arc stripe.

P_M_SHAPE_ELLIPSE, // Uncertainty shape is an ellipse.

P_M_SHAPE_ELLIPSE_SECTOR, // Uncertainty shape is an ellipse sector.

P_M_SHAPE_ELLIPSE_ARC_STRIPE // Uncertainty shape is an ellipse arc stripe.

};

// Defines the structure of data elements that specify a geographical position.

// An “ellipsoid point with uncertainty shape” defines the horizontal location.

// The reference system chosen for the coding of locations is the World Geodetic

// System 1984 (WGS 84).

struct TpGeographicalPosition {

TpFloat Longitude;

TpFloat Latitude;

TpLocationUncertaintyShape TypeOfUncertaintyShape;

TpFloat UncertaintyInnerSemiMajor;

TpFloat UncertaintyOuterSemiMajor;

TpFloat UncertaintyInnerSemiMinor;

TpFloat UncertaintyOuterSemiMinor;

TpInt32 AngleOfSemiMajor;

TpInt32 SegmentStartAngle;

TpInt32 SegmentEndAngle;

};

// Defines a diagnostic value that is reported in addition to an error by

// the Network User Location or User Status SCFs.

enum TpMobilityDiagnostic {

P_M_NO_INFORMATION, // No diagnostic information present.

// Valid for all type of errors.

P_M_APPL_NOT_IN_PRIV_EXCEPT_LST, // Application not in privacy exception list.

// Valid for ‘Unauthorised Application’ error.

P_M_CALL_TO_USER_NOT_SETUP, // Call to user not set-up. Valid for

// ‘Unauthorised Application’ error.

P_M_PRIVACY_OVERRIDE_NOT_APPLIC, // Privacy override not applicable. Valid for

// ‘Unauthorised Application’ error.

P_M_DISALL_BY_LOCAL_REGULAT_REQ, // Disallowed by local regulatory requirements.

// Valid for ‘Unauthorised Application’ error.

P_M_CONGESTION, // Congestion. Valid for ‘Position Method

// Failure’ error.

P_M_INSUFFICIENT_RESOURCES, // Insufficient resources. Valid for ‘Position

// Method Failure’ error.

P_M_INSUFFICIENT_MEAS_DATA, // Insufficient measurement data. Valid for

// ‘Position Method Failure’ error.

P_M_INCONSISTENT_MEAS_DATA, // Inconsistent measurement data. Valid for

// ‘Position Method Failure’ error.

P_M_LOC_PROC_NOT_COMPLETED, // Location procedure not completed. Valid for

// ‘Position Method Failure’ error.

P_M_LOC_PROC_NOT_SUPP_BY_USER, // Location procedure not supported by user.

// Valid for ‘Position Method Failure’ error.

P_M_QOS_NOT_ATTAINABLE // Quality of service not attainable. Valid for

// ‘Position Method Failure’ error.

};

// Defines an error that is reported by the Network User Location or User Status SCFs.

enum TpMobilityError {

P_M_OK, // No error occurred while processing the request.

P_M_SYSTEM_FAILURE, // System failure. The request can not be handled because

// of a general problem in the network user location SCF

// , the user status SCFor the

// underlying network. Fatal

P_M_UNAUTHORIZED_NETWORK, // Unauthorised network, The requesting network is

// not authorised to obtain the user’s location or

// status. Non fatal

P_M_UNAUTHORIZED_APPLICATION, // Unauthorised application. The application is

// not authorised to obtain the user’s location

// or status. Fatal

P_M_UNKNOWN_SUBSCRIBER, // Unknown subscriber. The user is unknown, i.e. no

// such subscription exists. Fatal

P_M_ABSENT_SUBSCRIBER, // Absent subscriber. The user is currently not

// reachable. Non fatal

P_M_POSITION_METHOD_FAILURE // Position method failure. The network user location SCF

// failed to obtain the user’s position. Non fatal

};

// This enumeration is used in requests to stop network user location or user status
// reports that are

// sent from a network user location or user status SCFs to an application.

enum TpMobilityStopScope {

P_M_ALL_IN_ASSIGNMENT, // The request concerns all users in an assignment.

P_M_SPECIFIED_USERS // The request concerns only the users that are

// explicitly specified in a collection.

};

// Defines the structure of data element that specifies a request to stop whole or parts of an

// assignment. Assignments are used for periodic or triggered reporting of a

// user locations or statuses. Observe that the parameter ‘Users’ is optional.

// If the parameter ‘stopScope’ is set to P_M_ALL_IN_ASSIGNMENT, the parameter

// ‘stopScope’ is undefined. If the parameter stopScope is set to

// P_M_SPECIFIED_USERS, then the assignment shall be stopped only for the users

// specified in the ‘users’ collection.

struct TpMobilityStopAssignmentData {

// Identity of the session that shall be stopped.

TpSessionID AssignmentId;

// Specify if only a part of the assignment or if whole the assignment

// shall be stopped.

TpMobilityStopScope StopScope;

// Optional parameter describing which users a stop request is

// addressing when only a part of an assignment is to be stopped.

TpAddressSet Users;

};

}; }; }; };

9.6.2 Network User Location: MMul.idl

/**************************************************************************/

// Data Definitions & Interfaces

// Network User Location

/**************************************************************************/

#include <MM.idl>

module org {

module threegpp {

module osa {

module mm {

module ul {

/**************************************************************************/

// Data definitions

/**************************************************************************/

// This data type is identical to a TString. It specifies the Cell Global

// Identification or the Location Area Identification (LAI).

// The Cell Global Identification (CGI) is defined as the string of characters

// in the following format:

// MCC-MNC-LAC-CI

// where:

// MCC Mobile Country Code (three decimal digits)

// MNC Mobile Network Code (two or three decimal digits)

// LAC Location area code (four hexadecimal digits)

// CI Cell Identification (four hexadecimal digits)

//

// The Location Area Identification (LAI) is defined as a string of characters

// in the following format:

// MCC-MNC-LAC

// where:

// MCC Mobile Country Code (three decimal digits)

// MNC Mobile Network Code (two or three decimal digits)

// LAC Location area code (four hexadecimal digits)

// The length of the parameter indicates which format is used. See 3GPP TS 29.002 for

// the detailed coding.

typedef TpString TpLocationCellIDOrLAI;

// Defines the structure of data elements that specifies the criteria for a

// triggered location report to be generated.

struct TpLocationTriggerCamel {

TpBoolean UpdateInsideVlr; // Generate location report when it occurs an

// location update inside the current VLR area.

TpBoolean UpdateOutsideVlr;// Generate location report when the user moves

// to another VLR area.

};

// Defines the structure of data elements that specifies the location of a mobile

// telephony user. Observe that if the StatusCode is indicating an error ,

// then neither GeographicalPosition, Timestamp, VlrNumber, LocationNumber,

// CellIdOrLai nor their associated presense flags are defined.

struct TpUserLocationCamel {

TpAddress UserID; // The address of the user.

TpMobilityError StatusCode; // Indicator of error.

TpBoolean GeographicalPositionPresent; // Flag indicating if the

// geographical position is present.

TpGeographicalPosition GeographicalPosition; // Specification of a position

// and an area of uncertainty.

TpBoolean TimestampPresent; // Flag indicating if the timestamp is present.

TpDateAndTime Timestamp; // Timestamp indicating when the location information// was attained

TpBoolean VlrNumberPresent; // Flag indicating if the VLR number is present.

TpAddress VlrNumber; // Current VLR number for the user.

TpBoolean LocationNumberPresent; // Flag indicating if the location

// number is present.

TpAddress LocationNumber; // Current location number.

TpBoolean CellIdOrLaiPresent; // Flag indicating if cell-id or

// LAI of the user is present.

TpLocationCellIDOrLAI CellIdOrLai; // Cell-id or LAI of the user.

};

typedef sequence <TpUserLocationCamel> TpUserLocationCamelSet;

/**************************************************************************/

// Interface definitions

/**************************************************************************/

interface IpAppUserLocationCamel; // Forward definition

// Inherits from the generic service capability feature interface.

// This interface is the SCF manager’s interface for Network User Location.

interface IpUserLocationCamel : IpService {

// Request for mobile-related location information on one or several wireles users.

void locationReportReq(

in IpAppUserLocationCamel appLocationCamel,

in TpAddressSet users,

out TpSessionID assignmentId)

raises (TpGeneralException);

// Request for periodic mobile location reports on one or several users.

void periodicLocationReportingStartReq(

in IpAppUserLocationCamel appLocationCamel,

in TpAddressSet users,

in TpDuration reportingInterval,

out TpSessionID assignmentId)

raises (TpGeneralException);

// This method stops the sending of periodic mobile location reports for

// one or several users.

void periodicLocationReportingStop(

in TpMobilityStopAssignmentData stopRequest)

raises (TpGeneralException);

// Request for user location reports, containing mobile related information,

// when the location is changed (the report is triggered by the location change).

void triggeredLocationReportingStartReq(

in IpAppUserLocationCamel appLocationCamel,

in TpAddressSet users,

in TpLocationTriggerCamel trigger,

out TpSessionID assignmentId)

raises (TpGeneralException);

// Request that triggered mobile location reporting should stop.

void triggeredLocationReportingStop(

in TpMobilityStopAssignmentData stopRequest)

raises (TpGeneralException);

};

// Inherits from the generic service capability feature interface.

// The network user location application interface is implemented by the client

// application developer and is used to handle location reports that are

// specific for mobile telephony users.

interface IpAppUserLocationCamel : IpOsa {

// Delivery of a mobile location report. The report is containing

// mobile-related location information for one or several users.

void locationReportRes(

in TpSessionID assignmentId,

in TpUserLocationCamelSet locations)

raises (TpGeneralException);

// This method indicates that the location report request has failed.

void locationReportErr(

in TpSessionID assignmentId,

in TpMobilityError cause,

in TpMobilityDiagnostic diagnostic);

// Periodic delivery of mobile location reports. The reports are

// containing mobile-related location information for one or several users.

void periodicLocationReport(

in TpSessionID assignmentId,

in TpUserLocationCamelSet locations)

raises (TpGeneralException);

// This method indicates that a requested periodic location report has

// failed. Note that errors only concerning individual users are reported

// in the ordinary periodicLocationReport() message.

void periodicLocationReportErr(

in TpSessionID assignmentId,

in TpMobilityError cause,

in TpMobilityDiagnostic diagnostic);

// Delivery of a report that is indicating that one or several user’s

// mobile location has changed.

void triggeredLocationReport(

in TpSessionID assignmentId,

in TpUserLocationCamel location,

in TpLocationTriggerCamel criterion)

raises (TpGeneralException);

// This method indicates that a requested triggered location report has

// failed. Note that errors only concerning individual users are reported

// in the ordinary triggeredLocationReport() message.

void triggeredLocationReportErr(

in TpSessionID assignmentId,

in TpMobilityError cause,

in TpMobilityDiagnostic diagnostic);

};

};};};};};

9.6.3 User Status: MMus.idl

/**************************************************************************/

// Data Definitions & Interfaces

// User Status

/**************************************************************************/

#include <MM.idl>

module org {

module threegpp {

module osa {

module mm {

module us {

/**************************************************************************/

// Data definitions

/**************************************************************************/

// Defines the status of a user.

enum TpUserStatusIndicator {

P_US_REACHABLE, // User is reachable

P_US_NOT_REACHABLE, // User is not reachable

P_US_BUSY // User is busy (only applicable for interactive user

// status request, not when triggers are used)

};

// Defines the structure of data elements that specify the identity

// and status of a user.

struct TpUserStatus {

TpAddress UserID; // The user address.

TpMobilityError StatusCode; // Indicator of error.

TpUserStatusIndicator Status; // The current status of the user.

};

typedef sequence <TpUserStatus> TpUserStatusSet;

/**************************************************************************/

// Interface definitions

/**************************************************************************/

interface IpAppUserStatus; // Forward definition

// Inherits from the generic service capability feature interface.

// The user status interface represents the interface to the user status SCF.

interface IpUserStatus : IpService {

// Request for a report on the status of one or several users.

void statusReportReq(

in IpAppUserStatus appStatus,

in TpAddressSet users,

out TpSessionID assignmentId)

raises (TpGeneralException);

// Request for triggered status reports when one or several user’s

// status is changed. The user status SCF will send a report when

// the status changes.

void triggeredStatusReportingStartReq (

in IpAppUserStatus appStatus,

in TpAddressSet users,

out TpSessionID assignmentId)

raises (TpGeneralException);

// This method stops the sending of status reports for one or several users.

void triggeredStatusReportingStop (

in TpMobilityStopAssignmentData stopRequest)

raises (TpGeneralException);

};

// Inherits from the base osa interface.

// The user-status application interface is implemented by the client

// application developer and is used to handle user status reports.

interface IpAppUserStatus : IpOsa {

// Delivery of a report, that is containing one or several user’s status.

void statusReportRes(

in TpSessionID assignmentId,

in TpUserStatusSet status)

raises (TpGeneralException);

// This method indicates that the status report request has failed.

void statusReportErr(

in TpSessionID assignmentId,

in TpMobilityError cause,

in TpMobilityDiagnostic diagnostic);

// Delivery of a report that is indicating that a user’s status has changed.

void triggeredStatusReport(

in TpSessionID assignmentId,

in TpUserStatus status)

raises (TpGeneralException);

// This method indicates that a requested triggered status reporting has

// failed. Note that errors only concerning individual users are reported

// in the ordinary triggeredStatusReport() message.

void triggeredStatusReportErr(

in TpSessionID assignmentId,

in TpMobilityError cause,

in TpMobilityDiagnostic diagnostic);

};

};};};};};

9.7 Terminal Capabilities: TERMCAP.idl

#ifndef __TERMCAP_DEFINED

#define __TERMCAP_DEFINED

#include <OSA.idl>

module org {

module threegpp {

module osa {

module termcap {

enum TpTerminalCapabilitiesError {

P_TERMCAP_ERROR_UNDEFINED, /* Undefined */

P_TERMCAP_INVALID_TERMINALID, /* Terminal ID not valid */

P_TERMCAP_SYSTEM_FAILURE /* General problem in terminal capabilities SCF or in underlying network */

};

exception TpTermCapException {

TpTerminalCapabilitiesError error;

};

/* TpTerminalCapabilities: Structure containing status code and terminal

capabilities. */

struct TpTerminalCapabilities {

/* statusCode: Indicates whether or not the terminalCapabilities

are available. */

TpBoolean StatusCode;

/* terminalCapabilities: Specifies the latest available capabilities of the user´s terminal.

This information, if available, is returned as CC/PP headers as specified in W3C [6] and adopted in the WAP UAProf specification [9]. It contains URLs; terminal attributes and values, in RDF format; or a combination of both. */

TpString TerminalCapabilities;

};

interface IpTerminalCapabilities : IpService {

/* Method: getTerminalCapabilities()

This method is used by an application to get the capabilities of a

user’s terminal. Direction: Application to Network

In parameter TerminalIdentity: Identifies the terminal. It may be

a logical address known by the WAP Gateway/PushProxy.

Out parameter, see TerminalCapabilityStruct*/

void getTerminalCapabilities (

in TpString terminalIdentity,

out TpTerminalCapabilities result

)

raises (TpTermCapException, TpGeneralException);

};

};};};};

#endif

Annex A (informative):
Change history

Change history

Date

TSG #

TSG Doc.

CR

Rev

Subject/Comment

Old

New

Jun 2000

CN_08

NP-000310

Approval of Specification

2.0.0

3.0.0

Sep 2000

CN_09

NP-000519

001

1

Improvement of User Interaction STDs

3.0.0

3.1.0

Sep 2000

CN_09

NP-000519

003

2

Correction of numbering in TpResultInfo

3.0.0

3.1.0

Sep 2000

CN_09

NP-000519

004

1

Remove of E.164 Mobile and correction of numbering in TpAddressPlan

3.0.0

3.1.0

Sep 2000

CN_09

NP-000519

005

Common IDL interfaces for Generic Call Control and Generic User Interaction between 3GPP, ETSI SPAN3 and Parlay

3.0.0

3.1.0

Sep 2000

CN_09

NP-000519

006

Correction to table with overview of IDL files

3.0.0

3.1.0

Sep 2000

CN_09

NP-000519

007

Reduction in name scoping in IDL for createUICall operation on IpUICall interface

3.0.0

3.1.0

Sep 2000

CN_09

NP-000519

008

2

Alignment of Framework with Parlay 2.1, improvement on business entity identification

3.0.0

3.1.0

Sep 2000

CN_09

NP-000519

009

2

Alignment of Framework with Parlay 2.1, correction of missing service token

3.0.0

3.1.0

Sep 2000

CN_09

NP-000519

010

2

Alignment of Framework with Parlay 2.1, parameter name and data-type alignments

3.0.0

3.1.0

Sep 2000

CN_09

NP-000519

011

1

Alignment of Framework with Parlay 2.1, one interface per application correction

3.0.0

3.1.0

Sep 2000

CN_09

NP-000519

012

1

Alignment of Framework with Parlay 2.1, only one error returned in load manager query

3.0.0

3.1.0

Sep 2000

CN_09

NP-000519

013

1

Alignment of Framework with Parlay 2.1, missing operation fwUnavailableInd in IpAppFaultManager.

3.0.0

3.1.0

Sep 2000

CN_09

NP-000520

014

1

Alignment of Framework with Parlay 2.1, missing service properties parameter in getServiceManager() operation of IpSvcFactory.

3.0.0

3.1.0

Sep 2000

CN_09

NP-000520

015

1

Alignment of Framework with Parlay 2.1 undefined datatype in endaccess operation of IpAccess.

3.0.0

3.1.0

Sep 2000

CN_09

NP-000520

016

1

Alignment of Framework with Parlay 2.1, service and interface naming correction.

3.0.0

3.1.0

Sep 2000

CN_09

NP-000520

017

1

Alignment of Framework with Parlay 2.1, renaming of TpPropertyStruct to TpServiceTypeProperty

3.0.0

3.1.0

Sep 2000

CN_09

NP-000520

018

1

Alignment of Framework with Parlay 2.1 addition of DES 128 bit authentication.

3.0.0

3.1.0

Sep 2000

CN_09

NP-000520

019

2

Alignment of Framework with Parlay 2.1, improvement of load statistic data-types.

3.0.0

3.1.0

Sep 2000

CN_09

NP-000520

020

1

Correction in descriptive text for Call STD regarding user interaction in 2 Parties in Call State.

3.0.0

3.1.0

Sep 2000

CN_09

NP-000520

021

"Removal of double description of the type TpCallServiceCode".

3.0.0

3.1.0

Sep 2000

CN_09

NP-000520

022

1

"Removal of unused types TpUIMessageCriteria, TpEntOpID and TpEntOpIDList".

3.0.0

3.1.0

Sep 2000

CN_09

NP-000520

023

Alignment of Framework with Parlay 2.1, addition of setCallbackWithSessionID operation to IpService.

3.0.0

3.1.0

Sep 2000

CN_09

NP-000520

024

Clarification of life time of parameters in TpAuthDomain

3.0.0

3.1.0

Dec 2000

CN_10

NP-000718

025

Removal of the originatingAddress from the connectReq method in IpDataSession

3.1.0

3.2.0

Dec 2000

CN_10

NP-000718

026

1

Alignment between new ETSI document for common data and TS29.198

3.1.0

3.2.0

Dec 2000

CN_10

NP-000718

027

Correction of the type TpTerminalCapabilities

3.1.0

3.2.0

Dec 2000

CN_10

NP-000718

028

Incorrect Date and Time example in Data Definitions

3.1.0

3.2.0

Dec 2000

CN_10

NP-000718

029

Double IDL definition for TpGCCSException

3.1.0

3.2.0

Dec 2000

CN_10

NP-000718

030

Parameter EnabledOrDisbled in TpServiceTypeDescription

3.1.0

3.2.0

Dec 2000

CN_10

NP-000718

031

readonly is an IDL keyword

3.1.0

3.2.0

Dec 2000

CN_10

NP-000718

032

Error correction in the Scope definition, section 1

3.1.0

3.2.0

Dec 2000

CN_10

NP-000718

034

Specific exceptions for method invocations in invalid states

3.1.0

3.2.0

Dec 2000

CN_10

NP-000718

035

Unclear default value for TpAccessType

3.1.0

3.2.0

Dec 2000

CN_10

NP-000718

036

1

Unclear description for TpAuthType

3.1.0

3.2.0

Dec 2000

CN_10

NP-000718

037

TpInterfaceName in method obtainInterface()

3.1.0

3.2.0

Dec 2000

CN_10

NP-000718

038

Correction on numbering in TpCallAppInfoType

3.1.0

3.2.0

Dec 2000

CN_10

NP-000718

039

Addition of MonitorMode in TpCallEventInfo

3.1.0

3.2.0

Dec 2000

CN_10

NP-000718

040

Renaming of P_CALL_REPORT_REFUSED_BUSY

3.1.0

3.2.0

Dec 2000

CN_10

NP-000718

043

Removal of the parameter serviceProperties in the method selectService

3.1.0

3.2.0

Dec 2000

CN_10

NP-000718

044

Inclusion of missing state transitions in case call related information could not be retrieved.

3.1.0

3.2.0

Mar 2001

CN_11

NP-010133

045

Correction of IDL implementation of data-type TpDomainID

3.2.0

3.3.0

Mar 2001

CN_11

NP-010133

046

Correction to terminal capability parameter reference

3.2.0

3.3.0

Jun 2001

CN_12

NP-010325

048

IDL Correction of TpCallEventCriteria

3.3.0

3.4.0

  1. A typedef is a type definition declaration in IDL.

  2. The location number is the number to the MSC or in rare cases the roaming number.

  3. Only applicable to mobile (Wireless) telephony users.