#include <bt_sock.h>
| class CBluetoothSocket : public CBase |
This allows Bluetooth ACL socket-based services to be run.
It allows all user-plane data flow to occur, plus control-plane Bluetooth baseband modification capabilities.
For a more detailed description of RBTBaseband functionality see the class and function documentation for RBTPhysicalLinkAdapter.
This class doesn't provide the functionality to directly activate Active mode (this is implementated in class RBTPhysicalLinkAdapter.)
See also: RBTPhysicalLinkAdapter::ActivateActiveRequester() Explicit Active mode requests are made automatically when using the Automatic Sniff Requester utility provided by this class. CBluetoothSocket::SetAutomaticSniffModeRBTPhysicalLinkAdapter
| IMPORT_C | ~CBluetoothSocket | ( | ) |
Destructor
Cancels any outstanding Bluetooth socket functions and closes the socket. Note sockets should be closed or shutdown before destructor is called.
| IMPORT_C TInt | Accept | ( | CBluetoothSocket & | aBlankSocket | ) |
Accepts a connection from a remote Bluetooth socket.
The call extracts the first pending connection on a queue of sockets, the queue size being previously specified by Listen(). On successful completion the blank socket is given the handle of the new socket and it may then be used to transfer data. After completion the accept socket may be used to make further connections with new blank sockets (see Open() on how to open a blank socket).
See also: RSocket::Accept(CBluetoothSocket& aBlankSocket)
When this request completes, notification is sent to the MBluetoothSocketNotifier object supplied when this CBluetoothSocket was constructed. This is done in the function MBluetoothSocketNotifier::HandleAcceptCompleteL(TInt aErr)
| Parameter | Description |
|---|---|
| aBlankSocket | A socket opened as a blank socket. |
Returns: KErrNone if the connection is established. KErrInUse if a connection already exists.
| IMPORT_C TInt | Accept | ( | CBluetoothSocket & | aBlankSocket, |
| TDes8 & | aConnectData | |||
| ) | ||||
Reserved for future.
| Parameter | Description |
|---|---|
| aBlankSocket | a socket opened as a blank socket. |
| aConnectData | Data that may be received in connection. |
Returns: KErrNone if the connection is established. KErrInUse if a connection already exists.
Set up notification of baseband events
Elect to be notified whenever one of a user specified selection of baseband events occurs.
The notification takes place in the pure virtual function MBluetoothSocketNotifier::HandleActivateBasebandEventNotifierCompleteL(TInt aErr, TBTBasebandEventNotification& aEventNotification)
The FIRST notification will take place ALMOST INSTANTANEOUSLY and will be A FULL DESCRIPTION (OR SNAPSHOT) OF THE CURRENT STATE OF THE PHYSICAL LINK irrespective of the specified selection of events wanted. This first notification or snapshot has NOTHING to do with a baseband event occurring. Once this snapshot has taken place, all occurrences of the specified events from the instant of the snapshot onwards will be notified until CBluetoothSocket::CancelBasebandEventNotifier() is called.
See also: PhysicalLinkState(TUint32& aState) if only a single full description of the physical link state is required.
See also: TBTPhysicalLinkStateNotifier TBTPhysicalLinkStateNotifierCombinations
| Parameter | Description |
|---|---|
| aEventTypes | bitmask for those events for which notification is being requested (Combine elements of TBTPhysicalLinkStateNotifier and TBTPhysicalLinkStateNotifierCombinations) |
Returns: KErrNone if activated or KErrInUse if the baseband event notifier is already being used.
| IMPORT_C TInt | ActivateParkRequester | ( | ) |
Activate park requestor.
See also: RBTPhysicalLinkAdapter::ActivateParkRequester()
Returns: KErrNone if successful. KErrInUse if the socket is using automatic sniff mode.
| IMPORT_C TInt | ActivateSniffRequester | ( | ) |
See also: RBTPhysicalLinkAdapter::ActivateSniffRequester()
Returns: KErrNone if successful. KErrInUse if the socket is using automatic sniff mode.
Allow low power modes.
The power modes are indicated by aLowPowerModes.
See also: RBTPhysicalLinkAdapter::AllowLowPowerModes(TUint32 aLowPowerModes)
| Parameter | Description |
|---|---|
| aLowPowerModes | The low power mode. |
Returns: KErrNone if successful. KErrInUse if the socket is using automatic sniff mode.
| IMPORT_C void | AsyncDelete | ( | ) |
Asynchronous deletion of the CBluetoothSocket object.
Function will cause asynchronous deletion of CBluetoothSocket object. It should be called if associated MBluetoothSocketNotifier needs to delete CBluetoothSocket from any of its callback functions.
| IMPORT_C TBool | AutomaticSniffMode | ( | ) | const |
Reports the automatic sniff/unsniff requesting status of the socket.
Returns: ETrue if automatic sniff/unsniff has been selected for this socket.
Sets a Bluetooth socket address.
Sets the local address of a socket. When a socket is opened it has no name associated with it, and binding is required so data can be routed to the socket. Bind() should be called before Listen() or Connect().
See also: RSocket::Bind(TSockAddr& aAddr)
| Parameter | Description |
|---|---|
| aSockAddr | The address of the socket. |
Returns: aAddr The address of the socket.
| IMPORT_C void | CancelAccept | ( | ) |
Cancels the Accept() operation.
See also: RSocket::CancelAccept()
| IMPORT_C void | CancelAll | ( | ) |
Cancels all outstanding operations.
Calling it will cause all outstanding operations to cancel. Outstanding operations for a socket include: read, write, Ioctl, connect, accept, shutdown and the Baseband event notifier. All of these operations will be completed by this call.
| IMPORT_C void | CancelBasebandEventNotifier | ( | ) |
Cancels an active baseband notifier.
No further baseband events will be notified.
If this function is called when there is no active baseband notifier, it will do nothing.
| IMPORT_C void | CancelConnect | ( | ) |
Cancel an attempted connection.
See also: RSocket::CancelConnect()
| IMPORT_C void | CancelIoctl | ( | ) |
Cancels the Ioctl() asynchronous control operation.
See also: RSocket::CancelIoctl()
| IMPORT_C TInt | CancelLowPowerModeRequester | ( | ) |
Cancels the low power mode request.
See also: RBTPhysicalLinkAdapter::CancelLowPowerModeRequester()
Returns: KErrNone if successful. KErrInUse if the socket is using automatic sniff mode.
| IMPORT_C void | CancelRead | ( | ) |
Cancels an outstanding Read() operation.
Calling this function will cause any outstanding Read() operation to cancel.
See also: RSocket::CancelRead()
| IMPORT_C void | CancelRecv | ( | ) |
Cancels an outstanding Recv() operation.
Calling this function will cause any outstanding receive operation to cancel.
See also: RSocket::CancelRecv()
| IMPORT_C void | CancelSend | ( | ) |
Cancels an outstanding Bluetooth Send() operation.
Calling the function will cause an outstanding Bluetooth Send() operation to complete prematurely.
See also: RSocket::CancelSend()
| IMPORT_C void | CancelWrite | ( | ) |
Cancels an outstanding Write() operation.
Calling this operation will cause any outstanding Write() operation to cancel.
See also: RSocket::CancelWrite()
| IMPORT_C TInt | Connect | ( | TBTSockAddr & | aSockAddr | ) |
Opens a connection to a specific Bluetooth device by its address.
The address represents the address of the remote Bluetooth device. A socket may only have one connect operation outstanding at any one time. Once the connect is completed, the socket is ready to send or receive data. If a socket is unbound - i.e. Bind() has not been called yet - then it will automatically have a local address allocated.
See also: RSocket::Connect(TBTSockAddr& aAddr)
When this request completes, notification is sent to the MBluetoothSocketNotifier object supplied when this CBluetoothSocket was constructed. This is done in the function MBluetoothSocketNotifier::HandleConnectCompleteL(TInt aErr)
| Parameter | Description |
|---|---|
| aSockAddr | The address of the bluetooth device to which the connection is being made. |
Returns: KErrInUse if the device is already being used, else KErrNone is the connection is successful.
| IMPORT_C TInt | Connect | ( | TBTSockAddr & | aSockAddr, |
| const TDesC8 & | aConnectDataOut, | |||
| TDes8 & | aConnectDataIn | |||
| ) | ||||
Connects to a remote Bluetooth device by address with a defined data-out and data-in descriptor.
The address provided specifies the address of the remote Bluetooth host. Data can be sent in connect request packets, which may be provided in the data-out descriptor, or connect responses, which may be collected in the data-in descriptor.
A socket may only have one connect operation outstanding at any one time. Once the connect is completed, the socket is ready to send or receive data. If a socket is unbound - i.e. Bind() has not been called yet - then it will automatically have a local address allocated.
See also: RSocket::Connect(TBTSockAddr& aAddr,const TDesC8& aConnectDataOut,TDes8& aConnectDataIn)
When this request completes, notification is sent to the MBluetoothSocketNotifier object supplied when this CBluetoothSocket was constructed. This is done in the function MBluetoothSocketNotifier::HandleConnectCompleteL(TInt aErr).
| Parameter | Description |
|---|---|
| aSockAddr | The address of the remote Bluetooth device. |
| aConnectDataOut | A descriptor containing data to be sent. |
| aConnectDataIn | A descriptor to receive data. |
Returns: KErrInUse if the device is already being used, else KErrNone is the connection is successful.
| IMPORT_C TInt | Connect | ( | TBTSockAddr & | aAddr, |
| TUint16 | aServiceBits | |||
| ) | ||||
Sets the Service bits in the Class Of Device. If this is successful, the socket then opens a connection to a specific Bluetooth device by its address.
The address represents the address of the remote Bluetooth device. A socket may only have one connect operation outstanding at any one time. Once the connect is completed, the socket is ready to send or receive data. If a socket is unbound - i.e. Bind() has not been called yet - then it will automatically have a local address allocated.
See also: RSocket::Connect(TBTSockAddr& aAddr)
When this request completes, notification is sent to the MBluetoothSocketNotifier object supplied when this CBluetoothSocket was constructed. This is done in the function MBluetoothSocketNotifier::HandleConnectCompleteL(TInt aErr)
| Parameter | Description |
|---|---|
| aAddr | The address of the bluetooth device to which the connection is being made. |
Returns: KErrInUse if the device is already being used, else KErrNone is the connection is successful.
See also: RSocket::GetDisconnectData(TDes8& aDesc)
| Parameter | Description |
|---|---|
| aDesc | A descriptor for the disconnect data. |
Returns: KErrNone if successful.
Gets a socket option.
The socket server has options which are generic to all sockets and protocols may add specific options.
Options available for all protocols can be got with anOptionLevel set to KSOLSocket. See individual protocol notes for other socket options.
See also: RSocket::GetOpt(TUint aOptionName,TUint aOptionLevel,TDes8& aOption)
| Parameter | Description |
|---|---|
| aOptionName | An option identifier. |
| aOptionLevel | An option level. Option levels 'group' related options. |
| aOption | The option value as a descriptor. |
Returns: The socket options set.
Gets a socket option.
The socket server has options which are generic to all sockets and protocols may add specific options.
Options available for all protocols can be got with anOptionLevel set to KSOLSocket. See individual protocol notes for other socket options.
See also: RSocket::GetOpt(TUint aOptionName,TUint aOptionLevel,TDes8& aOption)
| Parameter | Description |
|---|---|
| aOptionName | An option identifier. |
| aOptionLevel | An option level. Option levels 'group' related options. |
| aOption | The option value as an integer. |
Returns: The socket options set.
| void | HandleActivateBasebandEventNotifierCompleteL | ( | TInt | aErr, |
| TBTBasebandEventNotification | aEventNotification | |||
| ) | ||||
| IMPORT_C TInt | Info | ( | TProtocolDesc & | aProtocol | ) |
Gets information about the protocol the socket is opened on.
See also: RSocket::Info(TProtocolDesc& aProtocol)
| Parameter | Description |
|---|---|
| aProtocol | The protocol on which the socket is opened. Note that if the socket is a null socket, and aProtocol is a null TProtocolDesc when it is passed in, if will be null on return as well. |
Returns: KErrNone if successful.
Applies an asynchronous control operation on a socket.
Data may be passed and received if a descriptor address is provided as an argument. Only one Ioctl() operation may be outstanding for each socket.
See also: RSocket::Ioctl(TUint aCommand,TDes8* aDesc,TUint aLevel)
When this request completes, notification is sent to the MBluetoothSocketNotifier object supplied when this CBluetoothSocket was constructed. This is done in the function MBluetoothSocketNotifier::HandleIoctlCompleteL(TInt aErr)
| Parameter | Description |
|---|---|
| aLevel | Control operation level. |
| aCommand | ioctl command. |
| aDesc | Pointer to a descriptor in which data may be sent and received on completion. |
Returns: KErrNone if the ioctl command is applied or KErrInUse if another ioctl command is still being used.
| IMPORT_C TInt | Ioctl | ( | TUint | aCommand, |
| TDes8 * | aDesc = NULL, | |||
| TUint | aLevel = KLevelUnspecified | |||
| ) | ||||
Applies an asynchronous control operation on a socket.
Data may be passed and received if a descriptor address is provided as an argument. Only one Ioctl() operation may be outstanding for each socket.
See also: RSocket::Ioctl(TUint aCommand,TDes8* aDesc,TUint aLevel)
When this request completes, notification is sent to the MBluetoothSocketNotifier object supplied when this CBluetoothSocket was constructed. This is done in the function MBluetoothSocketNotifier::HandleIoctlCompleteL(TInt aErr) Deprecated
| Parameter | Description |
|---|---|
| aCommand | ioctl command. |
| aDesc | Pointer to a descriptor in which data may be sent and received on completion. |
| aLevel | Control operation level. |
Returns: KErrNone if the ioctl command is applied or KErrInUse if another ioctl command is still being used.
Sets up a socket to listen for incoming connections.
Before calling this procedure a socket should be opened using Open() and be bound to a local address using Bind().
Listen() creates a queue to hold incoming connections which can be married with blank sockets using Accept().
Once a listen queue has been created it will continue to allow peers to connect until it is full, at which point it will reject any incoming connections as specified by protocol behaviour. When a socket is accepted by the client a space is made available in the queue.
See also: RSocket::Listen(TUint qSize)
| Parameter | Description |
|---|---|
| qSize | The number of connections allowed in the queue. |
Returns: The 'listen' queue.
Reserved for future.
See also: RSocket::Listen(TUint qSize,const TDesC8& aConnectData)
| Parameter | Description |
|---|---|
| qSize | The size of the 'listen' queue. |
| aConnectData | The descriptor for data sent in connection respoonses. |
Returns: The 'listen' queue.
Sets the Service bits in the Class Of Device. If this is successful, the socket will then be set to Listen for incoming connections.
Before calling this procedure a socket should be opened using Open() and be bound to a local address using Bind().
Listen() creates a queue to hold incoming connections which can be married with blank sockets using Accept().
Once a listen queue has been created it will continue to allow peers to connect until it is full, at which point it will reject any incoming connections as specified by protocol behaviour. When a socket is accepted by the client a space is made available in the queue.
See also: RSocket::Listen(TUint qSize)
| Parameter | Description |
|---|---|
| qSize | The number of connections allowed in the queue. |
Returns: The 'listen' queue.
| IMPORT_C void | LocalName | ( | TSockAddr & | aSockAddr | ) |
Gets the local address of a socket.
The local address is set either by calling Bind() or it is automatically set when Connect() is called. If a socket is created through Accept() then a socket will inherit the port of its parent unless otherwise specified by a protocol's behaviour.
See also: RSocket::LocalName(TSockAddr& aAddr)
| Parameter | Description |
|---|---|
| aSockAddr | The socket address. |
Used to get a unique name of a socket.
The name is needed when Transfer() is called.
See also: RSocket::Name(TName& aName)
| Parameter | Description |
|---|---|
| aName | The system name of a socket. |
Returns: KErrNone if successful.
| IMPORT_C CBluetoothSocket * | NewL | ( | MBluetoothSocketNotifier & | aNotifier, |
| RSocketServ & | aServer, | |||
| TUint | aSockType, | |||
| TUint | aProtocol | |||
| ) | [static] | |||
Standard Bluetooth socket NewL constructor.
| Parameter | Description |
|---|---|
| aNotifier | The object which will receive asynchronous events. |
| aServer | A handle to an existing session on the socket server (ESock). |
| aSockType | One of a set of values defined in es_sock.h, for example KSockStream. |
| aProtocol | An entry point into the Bluetooth stack, for example KL2CAP. |
Returns: The Bluetooth socket created with the constructor.
| IMPORT_C CBluetoothSocket * | NewL | ( | MBluetoothSocketNotifier & | aNotifier, |
| RSocketServ & | aServer, | |||
| TUint | aSockType, | |||
| TUint | aProtocol, | |||
| RConnection & | aConnection | |||
| ) | [static] | |||
| Parameter | Description |
|---|---|
| aNotifier | The object which will receive asynchronous events. |
| aServer | A handle to an existing session on the socket server (ESock) |
| aSockType | One of a set of values defined in es_sock.h, for example KSockStream |
| aProtocol | An entry point into the Bluetooth stack, for example KL2CAP |
| aConnection | A socket server management interface for a connection |
Returns: The Bluetooth socket created with the constructor.
| IMPORT_C CBluetoothSocket * | NewL | ( | MBluetoothSocketNotifier & | aNotifier, |
| RSocketServ & | aServer, | |||
| const TDesC & | aName | |||
| ) | [static] | |||
Bluetooth socket named protocol NewL() constructor.
| Parameter | Description |
|---|---|
| aNotifier | The object which will receive asynchronous events. |
| aServer | A handle to an existing session on the socket server (ESock) |
| aName | A descriptor containing the name of the protocol wanted for making a Bluetooth connection, for example _L("L2CAP") |
Returns: The Bluetooth socket created with the constructor.
| IMPORT_C CBluetoothSocket * | NewL | ( | MBluetoothSocketNotifier & | aNotifier, |
| RSocketServ & | aServer | |||
| ) | [static] | |||
Bluetooth blank socket NewL() constructor.
Opens a blank socket to be used when accepting an incoming connection. This socket should be used as the parameter when a listening socket calls CBluetoothSocket::Accept(CBluetoothSocket& aBlankSocket). When that connection completes this blank socket becomes the Bluetooth socket for that connection.
| Parameter | Description |
|---|---|
| aNotifier | The object which will receive asynchronous events. |
| aServer | A handle to an existing session on the socket server (ESock) |
Returns: The Bluetooth socket created with the constructor.
| IMPORT_C CBluetoothSocket * | NewL | ( | MBluetoothSocketNotifier & | aNotifier, |
| RSocketServ & | aServer, | |||
| RSocket & | aSocket | |||
| ) | [static] | |||
Bluetooth socket using an existing RSocket instance constructor.
Takes ownership of an existing socket to be used as the underlying connection for this Socket wrapper. This should be used where an existing API returned a RSocket representing a Bluetooth connection.
| Parameter | Description |
|---|---|
| aNotifier | The object which will receive asynchronous events. |
| aServer | A handle to an existing session on the socket server (ESock) |
| aSocket | A handle to an existing socket. |
Returns: The Bluetooth socket created with the constructor.
| IMPORT_C CBluetoothSocket * | NewLC | ( | MBluetoothSocketNotifier & | aNotifier, |
| RSocketServ & | aServer, | |||
| TUint | aSockType, | |||
| TUint | aProtocol | |||
| ) | [static] | |||
Standard Bluetooth socket NewLC constructor.
Opens a Bluetooth socket as with the NewL() above, but leaves the returned CBluetoothSocket object on the cleanup stack.
| Parameter | Description |
|---|---|
| aNotifier | The object which will receive asynchronous events. |
| aServer | A handle to an existing session on the socket server (ESock) |
| aSockType | One of a set of values defined in es_sock.h, for example KSockStream |
| aProtocol | An entry point into the Bluetooth stack, for example KL2CAP |
Returns: The Bluetooth socket created with the constructor.
| IMPORT_C CBluetoothSocket * | NewLC | ( | MBluetoothSocketNotifier & | aNotifier, |
| RSocketServ & | aServer, | |||
| TUint | aSockType, | |||
| TUint | aProtocol, | |||
| RConnection & | aConnection | |||
| ) | [static] | |||
This constructor opens a Bluetooth socket on a specified connection.
Leaves the socket on the cleanup stack.
| Parameter | Description |
|---|---|
| aNotifier | The object which will receive asynchronous events. |
| aServer | A handle to an existing session on the socket server (ESock) |
| aSockType | One of a set of values defined in es_sock.h, for example KSockStream |
| aProtocol | An entry point into the Bluetooth stack, for example KL2CAP |
| aConnection | A socket server management interface for a connection |
Returns: The Bluetooth socket created with the constructor.
| IMPORT_C CBluetoothSocket * | NewLC | ( | MBluetoothSocketNotifier & | aNotifier, |
| RSocketServ & | aServer, | |||
| const TDesC & | aName | |||
| ) | [static] | |||
Bluetooth socket named protocol NewLC() constructor.
Opens a Bluetooth socket over a specified named protocol, such as "L2CAP". Leaves returned CBluetoothSocket object on the cleanup stack.
| Parameter | Description |
|---|---|
| aNotifier | The object which will receive asynchronous events. |
| aServer | A handle to an existing session on the socket server (ESock) |
| aName | A descriptor containing the name of the protocol wanted for making a Bluetooth connection, for example _L("L2CAP") |
Returns: The Bluetooth socket created with the constructor.
| IMPORT_C CBluetoothSocket * | NewLC | ( | MBluetoothSocketNotifier & | aNotifier, |
| RSocketServ & | aServer | |||
| ) | [static] | |||
Bluetooth blank socket NewLC() constructor
Opens a blank socket to be used when accepting an incoming connection. This socket should be used as the parameter when a listening socket calls CBluetoothSocket::Accept(CBluetoothSocket& aBlankSocket). When that connection completes this blank socket becomes the Bluetooth socket for that connection.
Leaves returned CBluetoothSocket object on the cleanup stack.
| Parameter | Description |
|---|---|
| aNotifier | The object which will receive asynchronous events. |
| aServer | A handle to an existing session on the socket server (ESock) |
Returns: The Bluetooth socket created with the constructor.
| IMPORT_C CBluetoothSocket * | NewLC | ( | MBluetoothSocketNotifier & | aNotifier, |
| RSocketServ & | aServer, | |||
| RSocket & | aSocket | |||
| ) | [static] | |||
Bluetooth socket using an existing RSocket instance constructor.
Takes ownership of an existing socket to be used as the underlying connection for this Socket wrapper. This should be used where an existing API returned a RSocket representing a Bluetooth connection.
Leaves returned CBluetoothSocket object on the cleanup stack.
| Parameter | Description |
|---|---|
| aNotifier | The object which will receive asynchronous events. |
| aServer | A handle to an existing session on the socket server (ESock) |
| aSocket | A handle to an existing socket. |
Returns: The Bluetooth socket created with the constructor.
Get the state of the physical link.
See also: RBTPhysicalLinkAdapter::PhysicalLinkState(TUint32& aState)
| Parameter | Description |
|---|---|
| aState | The state of the physical link. |
Returns: The state of the physical link.
Prevents low power modes from being activated.
See also: RBTPhysicalLinkAdapter::PreventLowPowerModes(TUint32 aLowPowerModes)
| Parameter | Description |
|---|---|
| aLowPowerModes | The low power mode being prevented. |
Returns: KErrNone if successful. KErrInUse if the socket is using automatic sniff mode.
Receives data from a remote Bluetooth host.
Read() is only used with a connected Bluetooth host.
When this request completes, notification is sent to the MBluetoothSocketNotifier object supplied when this CBluetoothSocket was constructed. This is done in the function MBluetoothSocketNotifier::HandleReceiveCompleteL(TInt aErr)
See also: RSocket::Read(TDes8& aDesc)
| Parameter | Description |
|---|---|
| aDesc | A descriptor for the data being read. |
Returns: KErrNone meaning the operation was successful and data is being received from the remote device, or KErrInUse meaning a previous Recv() is not yet finished.
Receives data from a remote Bluetooth device.
When this request completes, notification is sent to the MBluetoothSocketNotifier object supplied when this CBluetoothSocket was constructed. This is done in the function MBluetoothSocketNotifier::HandleReceiveCompleteL(TInt aErr)
See also: RSocket::Recv(TDes8& aDesc,TUint flags)
| Parameter | Description |
|---|---|
| aDesc | A descriptor for the information being sent to the remote Bluetooth device. |
| flags | Bluetooth information flags. |
Returns: KErrNone meaning the operation was successful and data is being received from the remote device, or KErrInUse meaning a previous Recv() is not yet finished.
| IMPORT_C TInt | Recv | ( | TDes8 & | aDesc, |
| TUint | flags, | |||
| TSockXfrLength & | aLen | |||
| ) | ||||
Receives data from a remote Bluetooth device.
When this request completes, notification is sent to the MBluetoothSocketNotifier object supplied when this CBluetoothSocket was constructed. This is done in the function MBluetoothSocketNotifier::HandleReceiveCompleteL(TInt aErr)
See also: RSocket::Recv(TDes8& aDesc,TUint flags, TSockXfrLength& aLen)
| Parameter | Description |
|---|---|
| aDesc | A descriptor for the information being sent to the remote Bluetooth device. |
| flags | Bluetooth information flags. |
| aLen | A length indicating how much data was read. This is the same as length of the returned aDesc. |
Returns: KErrNone meaning the operation was successful and data is being received from the remote device, or KErrInUse meaning a previous Recv() is not yet finished.
Receives aDesc data from the named remote aAddr Bluetooth device using the flags indicated.
See also: RSocket::RecvFrom(TDes8& aDesc,TSockAddr& aAddr,TUint flags)
When this request completes, notification is sent to the MBluetoothSocketNotifier object supplied when this CBluetoothSocket was constructed. This is done in the function MBluetoothSocketNotifier::HandleReceiveCompleteL(TInt aErr)
| Parameter | Description |
|---|---|
| aDesc | A descriptor for the data being received. |
| aSockAddr | The address of the Bluetooth device. |
| flags | The Bluetooth flags. |
Returns: KErrNone meaning the operation was successful and data is being received from the specified and addressed remote device, or KErrInUse meaning a previous RecvFrom() is not yet finished.
| IMPORT_C TInt | RecvFrom | ( | TDes8 & | aDesc, |
| TSockAddr & | aSockAddr, | |||
| TUint | flags, | |||
| TSockXfrLength & | aLen | |||
| ) | ||||
Receives aDesc data from the named remote aAddr Bluetooth device using the flags indicated.
See also: RSocket::RecvFrom(TDes8& aDesc,TSockAddr& aAddr,TUint flags,TSockXfrLength& aLen)
When this request completes, notification is sent to the MBluetoothSocketNotifier object supplied when this CBluetoothSocket was constructed. This is done in the function MBluetoothSocketNotifier::HandleReceiveCompleteL(TInt aErr)
| Parameter | Description |
|---|---|
| aDesc | A descriptor for the data being received. |
| aSockAddr | The address of the Bluetooth device. |
| flags | The Bluetooth flags. |
| aLen | An integer representing the length of the message. |
Returns: KErrNone meaning the operation was successful and data is being received from the specified and addressed remote device, or KErrInUse meaning a previous RecvFrom() is not yet finished.
| IMPORT_C TInt | RecvOneOrMore | ( | TDes8 & | aDesc, |
| TUint | flags, | |||
| TSockXfrLength & | aLen | |||
| ) | ||||
Receives data from a remote Bluetooth device, completing when data is available.
When this request completes, notification is sent to the MBluetoothSocketNotifier object supplied when this CBluetoothSocket was constructed. This is done in the function MBluetoothSocketNotifier::HandleReceiveCompleteL(TInt aErr).
See also: RSocket::RecvOneOrMore(TDes8& aDesc,TUint flags,TSockXfrLength& aLen)
| Parameter | Description |
|---|---|
| aDesc | A descriptor for the information being sent to the remote Bluetooth device. |
| flags | Bluetooth information flags. |
| aLen | A length indicating how much data was read. This is the same as length of the returned aDesc. |
Returns: KErrNone meaning the operation was successful and data is being received from the remote device, or KErrInUse meaning a previous Recv() is not yet finished.
| IMPORT_C void | RemoteName | ( | TSockAddr & | aSockAddr | ) |
Gets the remote address of a socket.
The remote name (address) of a socket is associated with the remote host the socket is connected to. The remote name is only valid for a connected socket. A socket is either connected through calling Connect() or Accept().
See also: RSocket::RemoteName(TSockAddr& aAddr)
| Parameter | Description |
|---|---|
| aSockAddr | The remote socket address. |
Request to change the supported packet types.
See also: RBTPhysicalLinkAdapter::RequestChangeSupportedPacketTypes(TUint16 aPacketTypes)
Returns: KErrNone if successful.
| IMPORT_C TInt | RequestMasterRole | ( | ) |
Request the socket take on the master role.
Returns: KErrNone if successful.
| IMPORT_C TInt | RequestSlaveRole | ( | ) |
Request the socket take on a slave role.
Returns: KErrNone if successful.
Sends data to a remote bluetooth device.
The Send() operation checks that another Send() operation isn't already in progress before sending.
When this request completes, notification is sent to the MBluetoothSocketNotifier object supplied when this CBluetoothSocket was constructed. This is done in the function MBluetoothSocketNotifier::HandleSendCompleteL(TInt aErr).
If Automatic Sniff Mode is active, using this function will not automatically put the link into active mode. If it is required that the link be taken out of sniff mode automatically when data is to be sent then the CBluetoothSocket::Write(const TDesC8& aDesc) function should be used instead.
See also: RSocket::Send(const TDesC8& aDesc,TUint someFlags,TRequestStatus& aStatus)
| Parameter | Description |
|---|---|
| aDesc | A descriptor for the data being sent to the remote device. |
| someFlags | Bluetooth specific flags. |
Returns: KErrNone meaning the operation was successful and data is being sent to the remote device, or KErrInUse meaning a previous Send() is not yet finished.
| IMPORT_C TInt | Send | ( | const TDesC8 & | aDesc, |
| TUint | someFlags, | |||
| TSockXfrLength & | aLen | |||
| ) | ||||
Sends data to a remote bluetooth device.
The Send() operation checks that another Send() operation isn't already in progress before sending.
When this request completes, notification is sent to the MBluetoothSocketNotifier object supplied when this CBluetoothSocket was constructed. This is done in the function MBluetoothSocketNotifier::HandleSendCompleteL(TInt aErr)
If Automatic Sniff Mode is active, using this function will not automatically put the link into active mode. If it is required that the link be taken out of sniff mode automatically when data is to be sent then the CBluetoothSocket::Write(const TDesC8& aDesc) function should be used instead.
See also: RSocket::Send(const TDesC8& aDesc,TUint someFlags,TSockXfrLength& aLen)
| Parameter | Description |
|---|---|
| aDesc | A descriptor for the data being sent to the remote device. |
| someFlags | Bluetooth specific flags. |
| aLen | Amount of data being sent. |
Returns: KErrNone meaning the operation was successful and data is being sent to the remote device, or KErrInUse meaning a previous Send() is not yet finished.
Sends the aDesc data to the aAddr specified and applies the flags indicated to the operation.
See also: RSocket::SendTo(const TDesC8& aDesc,TSockAddr& aAddr,TUint flags)
When this request completes, notification is sent to the MBluetoothSocketNotifier object supplied when this CBluetoothSocket was constructed. This is done in the function MBluetoothSocketNotifier::HandleSendCompleteL(TInt aErr)
If Automatic Sniff Mode is active, using this function will not automatically put the link into active mode. If it is required that the link be taken out of sniff mode automatically when data is to be sent then the CBluetoothSocket::Write(const TDesC8& aDesc) function should be used instead.
| Parameter | Description |
|---|---|
| aDesc | A descriptor for the data being sent. |
| aSockAddr | The address of the Bluetooth device. |
| flags | The Bluetooth flags. |
Returns: KErrNone meaning the operation was successful and data is being sent to the specified and addressed remote device, or KErrInUse meaning a previous SendTo() is not yet finished.
| IMPORT_C TInt | SendTo | ( | const TDesC8 & | aDesc, |
| TSockAddr & | aSockAddr, | |||
| TUint | flags, | |||
| TSockXfrLength & | aLen | |||
| ) | ||||
Sends the aDesc data to the aAddr specified and applies the flags indicated to the operation.
See also: RSocket::SendTo(const TDesC8& aDesc,TSockAddr& aAddr,TUint flags,TSockXfrLength& aLen)
When this request completes, notification is sent to the MBluetoothSocketNotifier object supplied when this CBluetoothSocket was constructed. This is done in the function MBluetoothSocketNotifier::HandleSendCompleteL(TInt aErr)
If Automatic Sniff Mode is active, using this function will not automatically put the link into active mode. If it is required that the link be taken out of sniff mode automatically when data is to be sent then the CBluetoothSocket::Write(const TDesC8& aDesc) function should be used instead.
| Parameter | Description |
|---|---|
| aDesc | A descriptor for the data being sent. |
| aSockAddr | The address of the Bluetooth device. |
| flags | The Bluetooth flags. |
| aLen | An integer representing the length of the message. |
Returns: KErrNone meaning the operation was successful and data is being sent to the specified and addressed remote device, or KErrInUse meaning a previous SendTo() is not yet finished.
Sets up automatic sniff/unsniff requesting for the socket.
If Automatic Sniff requesting is being selected, a timer with default delay in seconds before the idle socket will request the link to go into sniff mode. The CBluetoothSocket::Write() method will clear an outstanding sniff requester and start the CAutoSniffDelayTimer active object which will issue another request for sniff mode once it times out.
If Automatic Sniff requesting is being deselected, a previous sniff requester will be cancelled.
If Automatic Sniff requesting is selected when it is already active, no change will be performed and KErrInUse will be returned
| Parameter | Description |
|---|---|
| aAutoSniffMode | ETrue if Automatic Sniff/Unsniff requests are required. |
Returns: KErrNone if the automatic sniff mode has been successfully changed. KErrInUse if automatic sniff mode is requested, when it is already active. KErrArgument if an invalid idle timer value for the sniff request is provided. A Symbian wide error code for another other error that might have occurred.
Sets up automatic sniff/unsniff requesting for the socket.
If Automatic Sniff requesting is being selected, supply the delay in seconds required before the idle socket will request the link to go into sniff mode. The CBluetoothSocket::Write() method will clear an outstanding sniff requester and start the CAutoSniffDelayTimer active object which will issue another request for sniff mode once it times out.
If Automatic Sniff requesting is being deselected, a previous sniff requester will be cancelled.
If Automatic Sniff requesting is selected when it is already active, no change will be performed and KErrInUse will be returned
| Parameter | Description |
|---|---|
| aAutoSniffMode | ETrue if Automatic Sniff/Unsniff requests are required. |
| aIdleSecondsBeforeSniffRequest | A delay after the socket becomes idle before it will request sniff mode. |
Returns: KErrNone if the automatic sniff mode has been successfully changed. KErrInUse if automatic sniff mode is requested, when it is already active. KErrArgument if an invalid idle timer value for the sniff request is provided. A Symbian wide error code for another other error that might have occurred.
Sets the local port of a Bluetooth socket.
Setting the local port is equivalent to calling Bind() with only the port set in the address.
See also: RSocket::SetLocalPort(TInt aPort)
| Parameter | Description |
|---|---|
| aPort | The socket port. |
Returns: aPort The socket port.
| IMPORT_C void | SetNotifier | ( | MBluetoothSocketNotifier & | aNewNotifier | ) |
Changes the owner (receiver of notifications) of the socket.
The previous notifier will not be deleted after the change has been made.
| Parameter | Description |
|---|---|
| aNewNotifier | The object which will receive asynchronous events. |
Sets a socket option.
The socket server has options which are generic to all sockets and protocols may add specific options.
Options available for all protocols can be set with anOptionLevel set to KSOLSocket. See individual protocol notes for other socket options.
See also: RSocket::SetOpt(TUint aOptionName, TUint aOptionLevel,const TDesC8& aOption)
| Parameter | Description |
|---|---|
| aOptionName | An option identifier. |
| aOptionLevel | An option level. Option levels 'group' related options. |
| aOption | The option value as an integer. |
Returns: The socket options set.
Sets a socket option.
The socket server has options which are generic to all sockets and protocols may add specific options.
Options available for all protocols can be set with anOptionLevel set to KSOLSocket. See individual protocol notes for other socket options.
See also: RSocket::SetOpt(TUint aOptionName, TUint aOptionLevel,const TDesC8& aOption)
Deprecated| Parameter | Description |
|---|---|
| aOptionName | An option identifier. |
| aOptionLevel | An option level. Option levels 'group' related options. |
| aOption | The option value as a descriptor. |
Returns: The socket options set.
Sets a socket option.
The socket server has options which are generic to all sockets and protocols may add specific options.
Options available for all protocols can be set with anOptionLevel set to KSOLSocket. See individual protocol notes for other socket options.
See also: RSocket::SetOpt(TUint aOptionName, TUint aOptionLevel,const TDesC8& aOption)
| Parameter | Description |
|---|---|
| aOptionName | An option identifier. |
| aOptionLevel | An option level. Option levels 'group' related options. |
| aOption | The option value as a descriptor. |
Returns: The socket options set.
| IMPORT_C TInt | Shutdown | ( | RSocket::TShutdown | aHow | ) |
Shuts down a connected socket. (The socket cannot be null.
See also: CBluetoothSocket::Info.)
The shutdown method allows input and output to be individually stopped for a protocol endpoint.
See also: RSocket::Shutdown(RSocket::TShutdown aHow)
When this request completes, notification is sent to the MBluetoothSocketNotifier object supplied when this CBluetoothSocket was constructed. This is done in the function MBluetoothSocketNotifier::HandleShutdownCompleteL(TInt aErr)
| Parameter | Description |
|---|---|
| aHow | Shutdown option. All variants complete when a socket is disconnected. |
Returns: KErrNone if successful or KErrInUse if the system is already trying to shutdown a connected socket.
| IMPORT_C TInt | Shutdown | ( | RSocket::TShutdown | aHow, |
| const TDesC8 & | aDisconnectDataOut, | |||
| TDes8 & | aDisconnectDataIn | |||
| ) | ||||
Reserved for future. The socket must not be null. (
See also: CBluetoothSocket::Info.) RSocket::Shutdown(RSocket::TShutdown aHow,const TDesC8& aDisconnectDataOut,TDes8& aDisconnectDataIn)
When this request completes, notification is sent to the MBluetoothSocketNotifier object supplied when this CBluetoothSocket was constructed. This is done in the function MBluetoothSocketNotifier::HandleShutdownCompleteL(TInt aErr)
| Parameter | Description |
|---|---|
| aHow | Shutdown option. All variants complete when a socket is disconnected. |
| aDisconnectDataOut | A descriptor to send data. |
| aDisconnectDataIn | A descriptor to recive data. |
Returns: KErrNone if successful or KErrInUse if the system is already trying to shutdown a connected socket.
| IMPORT_C TInt | Transfer | ( | RSocketServ & | aServer, |
| const TDesC & | aName | |||
| ) | ||||
Transfers a socket from one socket server session to another.
It creates the socket in the target session, and removes the socket from the source session. The call is made on an uninitialised RSocket object. The socket system name 'Name()' is used to identify the socket to transfer.
If the call fails, the socket that is being transferred remains with the original session. Success or failure can be checked on the originating socket by calling Info(), which returns KErrNone if the transfer failed, and KErrBadHandle if it succeeded.
See also: RSocket::Transfer(RSocketServ& aServer, const TDesC& aName)
| Parameter | Description |
|---|---|
| aServer | The session to which the socket is being transfered |
| aName | The system name of the socket being transfered. |
Returns: KErrNone if successful.
Writes to a remote Bluetooth device
See also: RSocket::Write(const TDesC8& aDesc)
When this request completes, notification is sent to the MBluetoothSocketNotifier object supplied when this CBluetoothSocket was constructed. This is done in the function MBluetoothSocketNotifier::HandleSendCompleteL(TInt aErr)
If Automatic Sniff Mode is active on this socket instance, then upon calling this function the link will be put into active mode. If no CBluetoothSocket::Write() calls are made for a period of the timeout specified during activation of the automatic sniffing then the link will be put back into sniff mode.
See also: CBluetoothSocket::SetAutomaticSniffMode(TBool aAutoSniffMode, TInt aIdleSecondsBeforeSniffRequest) CBluetoothSocket::SetAutomaticSniffMode(TBool aAutoSniffMode)
| Parameter | Description |
|---|---|
| aDesc | A descriptor for the data being sent to the remote Bluetooth device. |
Returns: KErrNone meaning the operation was successful and data is being sent to the remote device, or KErrInUse meaning a previous Write() is not yet finished.