Blackberry Java SDK 1327377 0217050809 005 6.0 ES (Network Communcation

BlackBerry Java SDK
Network Communication
Versión: 6.0
Guía de desarrollo
Publicado: 2011-02-16
SWD-1327377-0217050809-005
Contenido
1 Descripción general de comunicación de red................................................................................................... 3
2 API de comunicación......................................................................................................................................... 4
Comunicar con servidores HTTP....................................................................................................................... 5
Solicitar datos mediante un objeto BlockingSenderDestination............................................................... 6
Solicitar datos mediante un objeto NonBlockingSenderDestination........................................................ 7
Enviar datos mediante un objeto FireAndForgetDestination.................................................................... 10
Analizar un formato de datos común de Internet..................................................................................... 11
Suscribirse a un iniciador push......................................................................................................................... 11
Suscribirse a un iniciador push.................................................................................................................. 12
Enviar información de inicio de sesión a un servidor HTTP.............................................................................. 13
3 Transportes de red............................................................................................................................................ 15
Arquitectura: transportes de red...................................................................................................................... 15
Utilizar BlackBerry Enterprise Server como gateway de intranet..................................................................... 17
Utilizar el gateway de Internet de un proveedor de servicios inalámbricos..................................................... 18
4 Conexiones de red............................................................................................................................................ 19
API de red......................................................................................................................................................... 20
Elegir transportes de red mediante la API de red...................................................................................... 20
Abrir una conexión de red mediante la API de red.................................................................................... 21
Marco genérico de conexión (GCF)................................................................................................................... 23
Abrir una conexión de red mediante el GCF.............................................................................................. 23
Enviar y recibir datos mediante una conexión de red...................................................................................... 25
Opciones de transporte de red......................................................................................................................... 28
5 Trabajar con radios........................................................................................................................................... 30

Consultar la disponibilidad de la radio y cambiar su estado............................................................................. 30
6 Ejemplos de código........................................................................................................................................... 32
Muestra de código: solicitar datos mediante un objeto BlockingSenderDestination...................................... 32
Muestra de código: solicitar datos mediante un objeto NonBlockingSenderDestination................................ 34
Muestra de código: análisis de una estructura de datos de JSON.................................................................... 36
Muestra de código: recuperar una página Web mediante el API de red.......................................................... 40
Muestra de código: recuperar una página Web mediante el GCF.................................................................... 43
Muestra de código: determinar los transportes de red con cobertura suficiente mediante la API de red...... 46
Muestra de código: control de radios............................................................................................................... 47
Muestra de código: determinar el estado de un transporte de red mediante la API de red........................... 50
7 Glosario............................................................................................................................................................. 52
8 Comentarios..................................................................................................................................................... 55
9 Historial de revisión del documento................................................................................................................. 56
10 Aviso legal......................................................................................................................................................... 57
Guía de desarrollo Descripción general de comunicación de red
Descripción general de comunicación de red 1

Los dispositivos BlackBerry® utilizan tecnologías de comunicación de radio como Wi-Fi®, CDMA,o GPRS para
comunicarse mediante conexiones inalámbricas. Los dispositivos BlackBerry operan con transportes de red diferentes
a través de esas tecnologías de radio para conectarse con Internet o una red privada. Cada transporte ofrece ventajas
diferentes. Como desarrollador, debe elegir el transporte más apropiado para sus requisitos.
Cuando elija un transporte para su aplicación, debe tener en cuenta varios factores diferentes, incluidos:
• El tipo de usuario
• La importancia de la seguridad y la fiabilidad
• Las redes que la aplicación debe utilizar y admitir para los usuarios en itinerancia
• La cantidad de datos que espera enviar y recibir
• La necesidad de insertar datos por push de forma proactiva para actualizaciones y alertas
• La ubicación del servidor de destino (Internet o la intranet)
BlackBerry® Java® SDK 6.0 incluye tres API que puede utilizar para abrir una conexión de red.
Versión de
API Descripción BlackBerry
Device Software
API de comunicación La API de comunicación encapsula todas las operaciones 6.0 y posterior
requeridas para conectarse a un servidor HTTP situado en
Internet o detrás de un firewall de la empresa.
API de red La API de red ofrece una interfaz sencilla para acceder a 5.0 y posterior
muchas opciones relacionadas con la conexión y los
transportes de red.
Marco genérico de conexión El GCF ofrece una manera flexible de crear conexiones a la 4.0 y posterior
(GCF) red mediante el transporte de su elección.
Además de la funcionalidad que cada API ofrece, debe tener en cuenta si la API existe en la versión de BlackBerry®
Device Software que probablemente ejecuten sus dispositivos de destino. Por ejemplo, la API de comunicación
requiere BlackBerry Device Software 6.0. Debería escribir su propio código para realizar tareas similares en los
dispositivos que ejecuten BlackBerry Device Software 5.0 y anterior.
La solución BlackBerry también activa aplicaciones de servidor para insertar datos por push de forma proactiva en
dispositivos BlackBerry de un modo sumamente seguro y fiable.
3
Guía de desarrollo API de comunicación
API de comunicación 2
La API de Comunicación simplifica el proceso de interactuación con servicios Web y otras aplicaciones. Los objetos
que crea mediante esta API automatizan el proceso de búsqueda de un transporte de red disponible, creación de
una conexión segura para subprocesos y negociación de un intercambio de datos con el punto final del URI o la
dirección URL que especifique. La API se implementa en el paquete net.rim.device.api.io.messaging.
Dentro de la API de comunicación, los puntos finales del URI y la dirección URL se denominan destinos. Puede utilizar
objetos que implementen la interfaz de SenderDestination para enviar los datos a un servicio Web y acceder a
la respuesta. De forma similar, puede utilizar objetos que implementen la interfaz de ReceiverDestination para
suscribirse a un servicio push y ofrecer el acceso a mensajes nuevos de ese servicio. Debe utilizar la clase de
DestinationFactory para crear un objeto que implemente una de las subinterfaces de Destination que mejor
satisfaga sus requisitos.
Interfaz Descripción
BlockingSenderDestination Puede utilizar esta interfaz para enviar un mensaje a un servicio
Web, pero este objeto bloquea la ejecución de subprocesos
mientras espera una respuesta del servicio Web.
Alternativamente, BlockingSenderDestination puede
devolver un objeto de MessageFuture. Esto permite la ejecución
del subproceso para continuar hasta que invoque uno de los
métodos de get() del MessageFuture.
Cuando invoca sendReceive() en
BlockingSenderDestination para enviar un mensaje y espera
una respuesta, no lo debe invocar desde el subproceso de evento
principal.
NonBlockingSenderDestination Puede utilizar esta interfaz para enviar un mensaje a un servicio
web. En la lista de parámetros, pase su implementación de la
interfaz de MessageListener para recibir la respuesta del
servicio Web.
BlockingReceiverDestination Puede utilizar esta interfaz para suscribirse a un servicio push y
bloquear la ejecución de subprocesos hasta que reciba la
confirmación de su solicitud de suscripción.
NonBlockingReceiverDestination Puede utilizar esta interfaz para suscribirse a un servicio push. En
la lista de parámetros, pase su implementación de
MessageListener para recibir mensajes push.
FireAndForgetDestination Puede utilizar esta interfaz para enviar los datos a un servicio Web
cuando no espere una respuesta.
4
Guía de desarrollo Comunicar con servidores HTTP
Los datos que envía a y recibe de un servicio Web se ajustan en un objeto de Message. Puede establecer los
encabezados y el contenido de los datos que envía a un servicio Web en el objeto Message. Alternativamente, puede
permitir que la API de comunicación elija valores predeterminados razonables para su solicitud. Por ejemplo, puede
solicitar una página Web invocando SenderDestination.send() sin especificar un comando HTTP GET.
También puede indicar a la API que analice automáticamente los datos de la respuesta de un servicio Web. Si
implementa la interfaz de MessageProcessor con su clase de analizador, puede suministrar su objeto analizador
al método en DestinationFactory que crea su objeto de Destination. A continuación puede recuperar la
respuesta analizada mediante Message.getObjectPayload().
Los paquetes de net.rim.device.api.io.parser contienen procesadores de mensajes para una gran variedad
de formatos de datos estándar utilizados en el Internet. Los paquetes incluyen analizadores para:
• JSON
• RSS (RDF, Atom)
• SOAP
• XML
Para mejorar la eficiencia, la API de Comunicación ofrece respuestas largas desde servicios Web en un objeto de
InputStream. Una aplicación puede solicitar datos adicionales según sea necesario en lugar de descargar una gran
cantidad de datos de una sola vez y almacenarla en la memoria del dispositivo. Este enfoque le permite hacer un
mejor uso tanto del banda de la red como de la memoria.
Comunicar con servidores HTTP

Para enviar un comando a un servidor HTTP, necesita un objeto de SenderDestination para comunicarse con un
punto final. El objeto de SenderDestination es responsable de poner en cola los mensajes para la entrega y de
obtener los mensajes entrantes para la entrega. La clase de DestinationFactory crea y mantiene una lista de
objetos de Destination que puede utilizar para comunicarse con un punto final.
Antes de crear un SenderDestination, debe comprobar si existe uno invocando getSenderDestination().
Puede acceder a un destino existente proporcionando el nombre del objeto de Context que suministró cuando
invocó cualquiera de los métodos de DestinationFactory.create...().
Cuando termine de intercambiar datos con un punto final, debe invocar DestinationFactory.release() o
DestinationFactory.destory(). El método release() elimina la asociación entre un Destination y las colas
de mensajes entrantes y salientes. Después de invocar release(), la API sigue intentando entregar los mensajes
de la cola. Puede utilizar release() cuando su aplicación no esté en estado de envío y recepción de mensajes.
Además de eliminar la asociación entre un Destination y una cola del mensaje, destroy() también destruye la
cola del mensaje. Después de invocar destory(), se eliminará cualquier mensaje de la cola.
Un mensaje contiene los detalles de su comando, incluido el método de solicitud HTTP y cualquier dato adicional
que requiera. Si no especifica todos los parámetros para su mensaje, la API de comunicación proporciona valores
predeterminados.
5
Después de enviar su mensaje, puede que necesite escuchar una respuesta. Para objetos de
BlockingSenderDestination, debe crear un objeto de Thread cuando invoca uno de los métodos de
sendReceive(). Para objetos de NonBlockingSenderDestination, debe crear un objeto de
MessageListener para recibir la respuesta.
En cualquier caso, debe procesar un objeto de Message que contenga la respuesta. De forma predeterminada, el
cuerpo del Message contiene los datos sin procesar de respuesta. Puede elegir especificar un procesador de mensajes
del paquete de net.rim.device.api.io.parser o crear el suyo propio mediante la interfaz de
MessageProcessor.
Si es necesario, puede conectar múltiples procesadores de mensajes. La clase de MessageProcessorChain

comparte la memoria entre los objetos de MessageProcessor para mejorar la eficiencia. Por ejemplo, si recibe
datos de vídeo que utilizan codificación y compresión personalizadas, puede separar la lógica de codificación y
compresión en procesadores de mensajes distintos y, a continuación, usar MessageProcessorChain para
agruparlos.
Solicitar datos mediante un objeto BlockingSenderDestination

1. Importe las clases y las interfaces necesarias.
import net.rim.device.api.io.messaging.*;
import net.rim.device.api.io.URI;
2. Cree un subproceso desde el cual llamar a BlockingSenderDestination.sendReceive().
Thread t = new Thread( new Runnable()
{
public void run()
{
3. Cree un objeto de Message que contenga la respuesta de la dirección URL.
Message response = null;
4. Cree un objeto de URI para pasarlo a la clase de DestinationFactory.
URI uri = new URI("http://www.blackberry.com");
5. Cree un objeto de BlockingSenderDestination.
BlockingSenderDestination bsd = null;
6. Recupere el objeto de BlockingSenderDestination para su contexto, si existe.
try
{
bsd = (BlockingSenderDestination)
DestinationFactory.getSenderDestination
("MyContext", uri);
7. Si no existe un BlockingSenderDestination, cree uno.
6
if(bsd == null)
{
bsd = DestinationFactory.createBlockingSenderDestination
(new Context("MyContext"), uri);
}
8. Envíe un mensaje y espere la respuesta.
response = bsd.sendReceive();
9. Si el servicio Web envía una respuesta, procésela.
if(response != null)
{
processResponse(response);
}
}
10. Revise cualquier error que se produzca si el mensaje no se pudo enviar por alguna razón.
catch (Exception e)
{
// Process the error
}
11. Publique el BlockingSenderDestination.
finally
{
if(bsd != null)
{
bsd.release();
}
}
}
});
12. Inicie el subproceso.
t.start();
Después de terminar: Si su processResponse() actualiza la IU, debe hacer lo mismo en el subproceso de evento
principal, no en el subproceso que usted creó en esta tarea. Para obtener más información, lea el artículo de la base
de conocimientos en http://supportforums.blackberry.com/t5/Java-Development/Manage-UI-interactions/ta-p/
502378.
Puede ver una muestra de código completo, en "Muestra de código: solicitar datos mediante un objeto
BlockingSenderDestination"
Solicitar datos mediante un objeto NonBlockingSenderDestination

Antes de comenzar: Para solicitar datos mediante la clase de NonBlockingSenderDestination, cree un objeto
que implementa la interfaz de MessageListener. Para obtener más información, consulte "Implementar la interfaz
MessageListener".
7

2. Cree un objeto de Message que contenga la respuesta de la dirección URL.
URI uri = new URI("http://www.blackberry.com");
4. Cree un objeto de NonBlockingSenderDestination.
NonBlockingSenderDestination nbsd = null;
5. Cree una referencia a su MessageListener.
MyMessageListener msgListener = new MyMessageListener();
6. Recupere el objeto de NonBlockingSenderDestination para su contexto, si existe.
try
{
nbsd = (BlockingSenderDestination) DestinationFactory.getSenderDestination
("MyContext", uri);
7. Si no existe un NonBlockingSenderDestination, cree uno.
if(nbsd == null)
{
nbsd = DestinationFactory.createNonBlockingSenderDestination
(new Context("MyContext"), uri, msgListener);
}
8. Envíe un mensaje al servicio Web.
nbsd.send();
catch (Exception e)
{
}
Después de terminar: Publique NonBlockingSenderDestination cuando acabe de procesar la respuesta.

NonBlockingSenderDestination"
8
Implementar la interfaz MessageListener

Puede utilizar la interfaz de MessageListener para recibir los mensajes enviados por un objeto de
NonBlockingSenderDestination o los mensajes push enviados desde un iniciador push.
import java.io.IOException;
import java.io.InputStream;
2. Defina una clase que implemente la interfaz de MessageListener.
public class MyMessageListener implements MessageListener {
3. Implemente onMessage().
public void onMessage(Destination dest, Message incomingMessage)
{
4. Inicialice una variable de String que contenga los datos de la respuesta.
String payload = null;
5. Si la respuesta es un objeto de ByteMessage, recupere la respuesta como String y asígnelo a payload.
if (incomingMessage instanceof ByteMessage)
{
ByteMessage reply = (ByteMessage) incomingMessage;
payload = (String) reply.getStringPayload();
}
6. Si la respuesta es un StreamMessage, recupera la respuesta como un objeto de InputStream.
else if(incomingMessage instanceof StreamMessage)
{
StreamMessage reply = (StreamMessage) incomingMessage;
InputStream is = reply.getStreamPayload();
a. Si la respuesta es pequeña, convierta los contenidos de la transmisión en una matriz de byte.

byte[] data = null;
try
{
data = net.rim.device.api.io.IOUtilities.streamToBytes(is);
} catch (IOException e)
{
// process the error
}
b. Si la conversión fue correcta, convierta la matriz de byte a un String y asígnelo a payload.
if(data != null)
{
payload = new String(data);
}
}
9
7. Si payload contiene datos, muéstrelo.

if(payload!=null)
{
synchronized(Application.getEventLock())
{
UiApplication.getUiApplication().pushScreen
(new HTTPOutputScreen(payload));
}
}
Después de terminar: Implemente onMessageCancelled() y onMessageFailed() para procesar otras

notificaciones.
NonBlockingSenderDestination"
Enviar datos mediante un objeto FireAndForgetDestination

URI uri = new URI("http://www.example.com");
3. Cree un objeto de FireAndForgetDestination.
FireAndForgetDestination ffd = null;
4. Recupere el objeto de FireAndForgetDestination para su contexto, si existe.
try
{
ffd = (FireAndForgetDestination) DestinationFactory.getSenderDestination
("MyContext", uri);
5. Si no existe un FireAndForgetDestination, cree uno.
if(ffd == null)
{
ffd = DestinationFactory.createFireAndForgetDestination
(new Context("MyContext"), uri);
}
6. Cree un objeto de ByteMessage y complételo con información para enviar a un servicio Web.
ByteMessage myMsg = ffd.createByteMessage();
myMsg.setStringPayload("I love my BlackBerry device!");
7. Lance su mensaje como un HTTPMessage para configurar el método HTTP que quiera utilizar.
((HttpMessage) myMsg).setMethod(HttpMessage.POST);
10
Guía de desarrollo Suscribirse a un iniciador push
8. Envíe el mensaje al servicio Web.

ffd.sendNoResponse(myMsg);
catch (Exception e)
{
}
Analizar un formato de datos común de Internet

Puede configurar un objeto de Destination para que devuelva un objeto de Java® que contenga datos analizados
desde un formato estándar, como JSON. Para recuperar la estructura de datos en un objeto de Java, debe:
1. Especificar un objeto de MessageProcessor cuando invoque DestinationFactory.create...().
2. Recuperar la respuesta de su Destination.
3. Extraer los datos del objeto de Message devuelto en la respuesta.
Ejemplo de código
La muestra de código siguiente demuestra las tres acciones requeridas para recuperar un objeto de Java que contenga
una estructura de datos JSON.
import net.rim.device.api.io.messaging.*
import net.rim.device.api.io.parser.json.*
// Specify a MessageProcessor when you create your Destination
BlockingSenderDestination bsd = DestinationFactory(myContext, myURI,
new JSONMessageProcessor());
// Retrieve the response
Message response = bsd.sendReceive();
// Extract the Java object that contains the JSON data structure
Object payload = response.getObjectPayload();
Suscribirse a un iniciador push

Puede utilizar la API de comunicación para enviar una solicitud de suscripción al URI de un proveedor de contenido.
Además del objeto de SenderDestination que envía la solicitud de la suscripción, debe crear un objeto de
ReceiverDestination que defina el objeto de MessageListeneral que el dispositivo BlackBerry® debe entregar
los mensajes push entrantes de un URI dado.
La tabla siguiente describe los componentes que participan en una solicitud de suscripción.
11
Guía de desarrollo Suscribirse a un iniciador push
Componente Descripción
SenderDestination Este componente envía el mensaje de suscripción
al proveedor del contenido. Este componente es
opcional. Puede enviar un mensaje de suscripción
mediante cualquier tipo de conexión de red. Por
ejemplo, puede utilizar la API de red para crear un
HTTPConnection y enviar los parámetros de
suscripción manualmente.
Mensaje de suscripción La API de comunicación puede crear un mensaje de
suscripción con el formato adecuado por usted.
Puede invocar
BpsSubscriptionMessageBuilder.createB
yteSubscriptionMessage() para recuperar un
objeto de ByteMessage configurado para su
SenderDestination,
NonBlockingReceiverDestination y el
MessageListener donde quiere recibir los
mensajes push entrantes.
NonBlockingReceiverDestination Este componente asocia un URI particular con el
MessageListener donde quiere recibir los
mensajes push entrantes y un objeto de
InboundDestinationConfiguration.
InboundDestinationConfiguration Este componente especifica diversos parámetros
de servicios de push, como un indicador que
especifica si su aplicación debe iniciarse cuando
llega un mensaje de push nuevo. Puede crear un
InboundDestinationConfiguration
mediante la clase de
InboundDestinationConfigurationFactor
y.
MessageListener Este componente procesa los mensajes push
entrantes.
Suscribirse a un iniciador push

Esta tarea se centra en crear un mensaje de suscripción y el objeto de NonBlockingReceiverDestination para
una suscripción de BlackBerry® Push Service. Debe enviar su mensaje de suscripción mediante un objeto de
SenderDestination o creando una conexión de red manualmente.
Antes de comenzar: Obtenga un identificador de aplicación y el número de puerto local que su aplicación debe utilizar
para buscar mensajes entrantes. Proporcione estos detalles al proveedor de contenido que crea la aplicación push
de servidor.
12
Guía de desarrollo Enviar información de inicio de sesión a un servidor HTTP

2. Inicialice una variable de NonBlockingReceiverDestination para administrar la suscripción.
NonBlockingReceiverDestination nbrd = null;
3. Cree un objeto de MessageListener para procesar los mensajes push entrantes.
try
{
MyMessageListener pushListener = new MyMessageListener();
4. Cree un objeto de URI con la información del puerto que el proveedor de contenido le asigna a usted.
URI pushURI = URI.create("http://:101");
5. Cree un objeto de InboundDestinationConfiguration para establecer los parámetros para la suscripción
push.
InboundDestinationConfiguration config =
InboundDestinationConfigurationFactory.createBPSConfiguration
(true, // start this application when a push message arrives
false, // allow other applications to receive these push messages
false, // do not store these messages (persistence not supported)
"12-Ab234cD5eF67h890", // application ID,
BPSuri); // BlackBerry Push Service URI
6. Cree un NonBlockingReceiverDestination.
nbrd = DestinationFactory.createNonBlockingReceiverDestination
(config, pushURI, pushListener);
7. Cree un SenderDestination para enviar un mensaje de suscripción.
NonBlockingSenderDestination bpsDestination =
DestinationFactory.createNonBlockingSenderDestination
(myContext, uri, responseListener);
8. Configure un mensaje de suscripción.
ByteMessage subMsg =
BpsSubscriptionMessageBuilder.createByteSubscriptionMessage
(bpsDestination, nbrd, "user", "pwd");
9. Envíe el mensaje de suscripción.
bpsDestination.send(subMsg);
Enviar información de inicio de sesión a un servidor HTTP

Un objeto de Destination puede suministrar información de inicio de sesión, como el nombre de usuario y la
contraseña, cuando un servidor Web lo solicite. La información de inicio de sesión se almacena en el objeto de
Context que proporciona cuando crea un Destination mediante la clase de DestinationFactory.
13
Guía de desarrollo Enviar información de inicio de sesión a un servidor HTTP
Ejemplo de código
context = new Context("DemoContext", new CredentialsCollector() {

public UsernamePasswordCredentials getBasicAuthenticationCredentials
(String aeID, Hashtable properties) {
// Provide or retrieve authentication credentials here.
// For example, you could display a dialog box to ask your user
// to enter a username and password, then return them from
// this method.
return new UsernamePasswordCredentials("username", "password");
}
});
14
Guía de desarrollo Transportes de red
Transportes de red 3
Arquitectura: transportes de red
Un dispositivo BlackBerry® puede conectarse a una red inalámbrica mediante transportes diferentes. No todos los
dispositivos tienen acceso a todos los transportes. Por ejemplo, el transporte BlackBerry® Mobile Data Systemestá
sólo disponible para dispositivos registrados con un BlackBerry® Enterprise Server.
15
Guía de desarrollo Arquitectura: transportes de red
Transporte de red Descripción

TCP Wi-Fi® El transporte Wi-Fi crea una conexión a Internet o a redes privadas como
una doméstica o la de una empresa. Cuando la radio Wi-Fi se enciende, un
usuario de dispositivo BlackBerry o una aplicación pueden configurar el
dispositivo para que se conecte a Internet mediante este transporte.
Si procede, el dispositivo puede enviar automáticamente los datos a
BlackBerry Enterprise Server o BlackBerry® Internet Service Internet Service
por una conexión Wi-Fi. Por ejemplo, si el dispositivo se conecta a una red
Wi-Fi y se configura un perfil VPN para la empresa del usuario, el dispositivo
intenta conectarse a BlackBerry Enterprise Server por VPN mediante la
conexión Wi-Fi porque transmitir datos por Wi-Fi es generalmente menos
caro que otros transportes. Este comportamiento se conoce como
enrutamiento al menor coste.
TCP móvil El transporte TCP móvil crea una conexión a Internet a través del gateway
de Internet de un proveedor de servicios inalámbricos. Este método crea el
tipo más directo de conexión que a través de la radio móvil.
La mayoría de los proveedores de servicios inalámbricos configuran el
dispositivo BlackBerry de un usuario para utilizar el gateway de Internet del
proveedor. Sin embargo, cuando el usuario esta en itinerancia en una red
diferente, debe configurar el dispositivo para utilizar manualmente el
gateway de Internet de la red de itinerancia.
Si su aplicación utiliza este transporte, lo debe probar para cada proveedor
de servicios inalámbricos que su aplicación podría utilizar.
BlackBerry Internet Service El transporte de BlackBerry Internet Service crea una conexión al Internet
a través de BlackBerry® Infrastructure. Los datos que envía y recibe
mediante este transporte se comprimen y optimizan para la transmisión
por conexiones inalámbricas.
Las aplicaciones que utilizan el transporte BlackBerry Internet Service
automáticamente se benefician de enrutamiento al menor coste. El
dispositivo se conecta con una red Wi-Fi automáticamente, si hay una
disponible.
Nota: Para utilizar el transporte de BlackBerry Internet Service, debe
suscribirse a BlackBerry® Push Service. Para obtener más información, visite
http://na.blackberry.com/eng/developers/javaappdev/pushapi.jsp
BlackBerry MDS El transporte de BlackBerry MDS permite a un dispositivo BlackBerry
conectarse al BlackBerry Enterprise Server asociado mediante BlackBerry
Infrastructure o una conexión Wi-Fi.
16
Guía de desarrollo Utilizar BlackBerry Enterprise Server como gateway de intranet
Transporte de red Descripción

Para obtener más información, consulte "Utilizar BlackBerry Enterprise
Server como gateway de intranet".
WAP El transporte WAP crea una conexión a través del gateway AP de un
proveedor de servicios inalámbricos. Son compatibles WAP 1.0, 1.2 y 2.0.
Para admitir este transporte, un usuario o el proveedor de servicios
inalámbricos deben configurar los parámetros de la conexión WAP en el
dispositivo. Como resultado, puede que este transporte no lo admitan todas
las redes inalámbricas ni todos los planes de datos.
Si su aplicación utiliza este transporte, lo debe probar para cada proveedor
de servicios inalámbricos que su aplicación podría utilizar. Para obtener más
información, consulte "Uso de la gateway a Internet del proveedor de
servicios inalámbricos".
Para utilizar WAP 2.0, deberá recuperar el identificador de conexión del
libro de servicios. Para obtener más información acerca de la recuperación
de un identificador de conexión, consulte el artículo de la base de
conocimientos en http://supportforums.blackberry.com/t5/Java-
Development/What-Is-Network-API-alternative-for-legacy-OS/ta-p/
614822
Utilizar BlackBerry Enterprise Server como gateway de

intranet
Las empresas alojan BlackBerry® Enterprise Server trás sus firewall para permitir que los usuarios de dispositivos
BlackBerry accedan a la intranet de la empresa. El componente BlackBerry® Mobile Data System de BlackBerry
Enterprise Server incluye BlackBerry® MDS Services, que proporciona un servicio de proxy HTTP y TCP/IP para permitir
que las aplicaciones Java® de terceros lo utilicen como gateway altamente seguro para administrar conexiones HTTP
y TCP/IP a la intranet. Si utiliza BlackBerry Enterprise Server como gateway de intranet, todo el tráfico entre la
aplicación y BlackBerry Enterprise Server se cifra automáticamente utilizando el cifrado AES o Triple DES. Puesto que
BlackBerry Enterprise Server se encuentra tras el firewall de la empresa y ofrece un cifrado de datos inherente, las
aplicaciones se pueden comunicar con servidores de la aplicación y con servidores Web que se ubican en la intranet
de la empresa.
Si su aplicación se conecta a Internet y no a la intranet de la empresa, quizás pueda utilizar el BlackBerry Enterprise
Server al que se asocia el dispositivo como gateway. En este caso, las solicitudes de red viajan tras el firewall de la
empresa hacia BlackBerry Enterprise Server, que realiza la solicitud de red a Internet a través del firewall de la
empresa. Las empresas pueden establecer una política de TI para imponer que BlackBerry Enterprise Server sea el
gateway para todo el tráfico de red inalámbrica, incluido el tráfico destinado a Internet.
17
Guía de desarrollo Utilizar el gateway de Internet de un proveedor de servicios inalámbricos
Utilizar el gateway de Internet de un proveedor de servicios

inalámbricos
Muchos proveedores de servicios inalámbricos facilitan una gateway a Internet que ofrece conectividad TCP/IP
directa a Internet. Algunos proveedores de servicios inalámbricos también proporcionan una gateway WAP que
permite que las conexiones HTTP usen el protocolo WAP. BlackBerry® Java® Application puede utilizar cualquiera de
estas gateways para conectarse a Internet. Una aplicación BlackBerry® WebWorks™ puede utilizar cualquiera de
estas gateways para conectarse a Internet. Si la aplicación es para usuarios de dispositivos BlackBerry que están en
una red inalámbrica específica, la utilización de la gateway a Internet del proveedor de servicios inalámbricos, a
menudo, puede ofrecer conexiones rápidas y fiables. Si su aplicación es para usuarios en redes móviles diversas,
probar su aplicación con los diferentes gateway de Internet puede resultar complicado. En este caso, debería utilizar
el transporte de BlackBerry® Internet Service y utilizar el gateway de Internet del proveedor de servicios inalámbricos
como una conexión de respaldo para cuando el transporte de BlackBerry Internet Service no esté disponible.
18
Guía de desarrollo Conexiones de red
Conexiones de red 4
BlackBerry® Application Platform ofrece dos API que puede utilizar para crear conexiones a la red manualmente: la
API de red y el GCF. Las aplicaciones enfocadas a dispositivos BlackBerry® con BlackBerry® Device Software 5.0 y
posterior pueden utlizar la API de red. La API de red ofrece una interfaz sencilla para trabajar con los transportes de
red y para configurar una amplia gama de parámetros de conexión. Puede utilizar el GCF para crear conexiones a la
red en dispositivos que ejecuten versiones anteriores de BlackBerry Device Software. Sin embargo, usar el GCF
requiere conocer más API de BlackBerry® para descubrir los transportes disponibles y cómo configurarlos.
Sea cual sea la API elegida, el proceso de crear una conexión de red es semejante. Primero, abra una conexión de
red, a continuación, lea y escriba datos medainte esa conexión y, por último, cierre la conexión. Antes de abrir una
conexión, normalmente especificará un transporte, un protocolo y un punto final. Puede conectarse a recursos de
red mediante una gran variedad de protocolos. Sin embargo, sepa que no todos los transportes admiten todos los
protocolos. Por ejemplo, WAP 1.0 y 1.1 sólo admiten HTTP sobre WAP y HTTPS sobre WAP o WTLS. BlackBerry
Application Platform admite los protocolos siguientes:
• HTTP
• HTTPS
• socket
• TLS
• SSL
• UDP (Datagrama)
El protocolo y el punto final los determina su aplicación, pero el transporte lo determina el entorno operativo de sus
usuarios. Puede que necesite probar más de un transporte antes de poder hacer una conexión correcta. La tabla
siguiente sugiere las órdenes de la preferencia para aplicaciones de empresa y de consumo.
Tipo de usuario Orden de transportes preferidos

Empresa 1. BlackBerry® Mobile Data System
2. TCP Wi-Fi®
3. WAP 2.0
4. BlackBerry® Internet Service
5. TCP móvil
6. WAP 1.0 o 1.1
Consumidor 1. TCP Wi-Fi
2. WAP 2.0
3. BlackBerry Internet Service
4. BlackBerry MDS
5. TCP móvil
6. WAP 1.0 o 1.1
19
Guía de desarrollo API de red
Después de abrir una conexión, recibe un objeto de Connection que representa su conexión. El paquete de
javax.microedition.io contiene varias interfaces que puede utilizar para manipular un objeto de Connection.
Interfaz Descripción
HttpConnection Esta interfaz ofrece métodos para establecer el método de solicitud HTTP
(GET, POST, etcétera) y los encabezados, y enviar y recibir datos por la
conexión.
HttpsConnection Esta interfaz incluye todos los métodos en la interfaz de HttpConnection
y añade getSecurityInfo(), que devuelve el certificado suministrado
por el servidor Web.
SocketConnection Esta interfaz expone los métodos de envío de datos a y recibe los datos de
un host de la red mediante una conexión de socket.
SecureConnection Esta interfaz ofrece métodos para crear conexiones de socket TLS y SSL. Esta
interfaz incluye todos los métodos en la interfaz de SocketConnection y
añade getSecurityInfo(), que devuelve información de seguridad
sobre la conexión.
UDPDatagramConnection Esta interfaz ofrece métodos para recuperar información sobre la conexión
y crear objetos de datagrama nuevos.
InputConnection, Estas interfaces ofrecen acceso a las secuencias de datos de entrada y de
OutputConnection salida de una conexión.
Cuando esté listo para utilizar su conexión, lance el objeto de Connection según el protocolo que usó para abrir la
conexión. Necesitará las interfaces del InputConnection y el OutputConnection del paquete
javax.microedition.io para acceder a las funciones de envío y recepción del objeto de Connection. Esas
interfaces exponen las secuencias de datos de entrada y de salida del objeto de Connection. Para obtener más
información acerca de cómo enviar los datos mediante la conexión, consulte las clases de InputStream y
OutputStream en la referencia de API para BlackBerry® Java® SDK.
API de red
La API de red se implementa en el net.rim.device.api.io.transport y en los paquetes de
net.rim.device.api.io.transport.options . La mayoría de las funciones la proporciona el
ConnectionFactory y las clases de TransportInfo . Un objeto de ConnectionFactory devuelve un objeto
de ConnectionDescriptor que contiene un objeto de Connection y la información sobre el transporte a través
del cual se abrió la conexión.
Elegir transportes de red mediante la API de red

En la API de red, la clase de TransportInfo ofrece información sobre los transportes de red disponibles en un
dispositivo BlackBerry®. Puede obtener una lista de los transportes que tienen actualmente cobertura, o utilizar la
API para determinar si un transporte particular está disponible y tiene cobertura.
20
Si no proporciona una lista ordenada de transportes preferidos cuando abre una conexión, la API de red elige un
transporte por usted. Sin embargo, debe priorizar los transportes que su aplicación utilice según el tipo de usuario
objetivo de la misma. La API recorre una serie de tipos de transporte que establezca usted mediante
ConnectionFactory.setPreferredTransportTypes().
Después que enumere sus transportes preferidos, debe establecer las opciones para cualquier transporte que
requiere unas específicas. Por ejemplo, los transportes WAP 1.0 y 1.1 requieren información sobre un APN, la
autenticación de gateway, etcétera. Para obtener más información, consulte "Opciones de transporte de red".
También debe crear un objeto de CoverageStatusListener (en el paquete de
net.rim.device.api.io.transport), y registrarlo mediante TransportInfo.addListener(). El dispositivo
envía notificaciones a su aplicación acerca de los cambios en el estado de la cobertura para que su aplicación pueda
responder de forma adecuada.
Abrir una conexión de red mediante la API de red

Después de decidir qué transportes de red utilizar, puede abrir una conexión y utilizarla para enviar y recibir datos.
El objeto de ConnectionFactory es el responsable de abrir conexiones. Además de sus transportes preferidos,
puede utilizar el ConnectionFactory para configurar opciones de conexión como:
• Número máximo de intentos de conexión.
• Tiempo máximo invertido en intentos de conexión.
• Demora entre intentos de conexión.
• Tener en cuenta o no si se requiere cifrado entre los puntos de fin de la conexión.
Cuando estés listo para abrir una conexión, debe invocar uno de los métodos de
ConnectionFactory.getConnection(). Asegúrese de que llama a getConnection() en un subproceso
distinto del de evento principal. Para obtener más información acerca de cómo crear un subproceso, consulte la clase
de Thread en la referencia de la API para BlackBerry® Java® SDK.
Cuando abra una conexión correctamente, ConnectionFactory devuelve un objeto de
ConnectionDescriptor. El ConnectionDescriptor contiene un objeto de Connection y la información sobre
el transporte que se utilizó para abrir la conexión.
Para obtener más información, consulte "Abrir una conexión de red mediante la API de red" y "Enviar y recibir datos
mediante una conexión de red".
Abrir una conexión de red mediante la API de red

PRECAUCIÓN: El método de ConnectionFactory.getConnection() bloquea la ejecución del subproceso. Debe
crear un subproceso separado para llamar a getConnection().
import net.rim.device.api.io.transport.*;
import net.rim.device.api.io.transport.options.*;
import net.rim.device.api.io.transport.TransportInfo;
import net.rim.device.api.ui.UiApplication;
2. Cree una lista ordenada de transportes preferidos.
21
int[] intTransports =
{ TransportInfo.TRANSPORT_TCP_WIFI,
TransportInfo.TRANSPORT_WAP2,
TransportInfo.TRANSPORT_TCP_CELLULAR
}
3. Configure las opciones para el transporte TCP móvil si se aplica.
TcpCellularOptions tcpOptions = new TcpCellularOptions();
if(!TcpCellularOptions.isDefaultAPNSet())
{
tcpOptions.setApn("My APN");
tcpOptions.setTunnelAuthUsername("user");
tcpOptions.setTunnelAuthPassword("password");
}
4. Cree un objeto de ConnectionFactory.
ConnectionFactory factory = new ConnectionFactory();
5. Configure cualquier otra opción de ConnectionFactory aplicable a su aplicación. En este caso, TCP móvil es
uno de los transportes preferidos, así que configrue las opciones de transporte TCP móvil.
factory.setTransportTypeOptions(TransportInfo.TRANSPORT_TCP_CELLULAR, tcpOptions);
factory.setAttemptsLimit(5);
6. Cree un subproceso para recuperar la conexión. Si logró establecer la conexión, a continuación
ConnectionFactory devuelve un objeto de ConnectionDescriptor que puede utilizar. En este paso, pase
el objeto de ConnectionDescriptor método (displayContent()) que será responsable de mostrar el
contenido.
Thread t = new Thread(new Runnable()
{
public void run()
{
ConnectionDescriptor cd = _factory.getConnection
("http://www.blackberry.com");
if(cd != null)
{
Connection c = cd.getConnection();
displayContent(c);
}
}
});
t.start();
7. Implemente displayContent(). En este caso, envíe una pantalla que utilice un parámetro de Connection
para recuperar y mostrar el contenido, después de que el subproceso de recuperación de la conexión finalice.
private void displayContent(final Connection conn)
{
UiApplication.getUiApplication().invokeLater(new Runnable()
{
public void run() {
UiApplication.getUiApplication().pushScreen(new HTTPOutputScreen(conn));
22
Guía de desarrollo Marco genérico de conexión (GCF)
}
});
}
Después de terminar: Para obtener más información acerca cómo usar una conexión e implementar la clase de
HTTPOutputScreen, consulte "Enviar y recibir datos mediante una conexión de red".
Para ver una muestra de código completo, consulte "Muestra de código: recuperar una página Web mediante la API
de red".
Marco genérico de conexión (GCF)

Si desarrolla aplicaciones para usuarios de dispositivos BlackBerry® que ejecutan BlackBerry® Device Software 4.7 o
anterior, debe utilizar el GCF para abrir una conexión de red. Sin embargo, cualquier código que escriba y use el GCF
también funciona en versiones posteriores de BlackBerry® Device Software. El GCF se implementado en la clase de
javax.microedition.io.Connector. Puede llamar a Connector.open() para crear cualquier tipo de conexión
admitido. El método de open() acepta cadenas de conexión que especifiquen el tipo de conexión que quiere realizar,
el punto final y los detalles opcionales de configuración para la conexión.
La cadena de conexión que usa el GCF se compone de partes:
<scheme> : <hierarchical location information> ; <additional information>
<scheme> indica el protocolo que se utilizará para establecer la conexión. <hierarchical location information> describe
el punto final para la conexión. Por último, <additional information> controla el transporte utilizado y proporciona
los detalles de autenticación para un servidor proxy si son necesarios. Para obtener más información acerca de las
opciones de transporte, consulte "Opciones de transporte de red".
Por ejemplo, en la muestra de código siguiente, la cadena de conexión especifica el protocolo HTTP y utiliza un
nombre de host para indicar el punto final de la conexión. El parámetro interface=wifi se incluye para especificar
que la radio Wi-Fi® debe utilizarse para establecer la conexión.
HTTPConnection c = (HTTPConnection)Connector.open("http://
example.com;interface=wifi");
Abrir una conexión de red mediante el GCF

La tarea siguiente le muestra cómo abrir una conexión HTTP mediante el transporte BlackBerry® Mobile Data System.
Puede utilizar un proceso semejante para abrir una conexión mediante otros protocolos y transportes.
PRECAUCIÓN: El método de Connector.open() no es seguro en subprocesos. Asegúrese de que llama a open()
en un subproceso distinto del de evento principal.
Antes de comenzar: Aségurese de que el transporte que quiere utilizar está disponible y tiene cobertura.

import javax.microedition.io.*;
23
Guía de desarrollo Marco genérico de conexión (GCF)
2. Cree un subproceso nuevo para abrir la conexión.

{
public void run()
{
3. Cree una variable local para su objeto de Connection.
Connection conn = null;
4. Invoque open(). Especifique la cadena de conexión.
try
{
conn = Connector.open("http://www.blackberry.com;deviceside=false");
} catch (IOException e)
{
// Process your error condition
}
5. Si logró establecer la conexión, a continuación open() devuelve un objeto de Connection que puede utilizar.
Pase el objeto de conexión a otro método (displayContent()) que será responsable de mostrar el contenido.
if (conn != null)
{
displayContent(conn);
}
}
});
6. Inicie su subproceso.
t.start();
7. Implemente displayContent(). En este caso, envíe una pantalla que utilice un parámetro de Connection
para recuperar y mostrar el contenido, después de que el subproceso de recuperación de la conexión finalice.
{
{
public void run() {
}
});
}
Después de terminar: Para obtener más información acerca cómo usar una conexión e implementar la clase de
HTTPOutputScreen, consulte "Enviar y recibir datos mediante una conexión de red".
Para ver una muestra de código completo, consulte "Muestra de código: recuperar una página Web mediante el GCF".
24
Guía de desarrollo Enviar y recibir datos mediante una conexión de red
Enviar y recibir datos mediante una conexión de red

La tarea siguiente le muestra cómo enviar y recibir datos mediante una conexión HTTP con un sitio Web. Los datos
devueltos del sitio Web se muestran en la pantalla. Puede utilizar un proceso semejante para enviar y recibir los
datos mediante otros protocolos de red. Para hacer esta tarea tan general como sea posible, el código siguiente
envía un comando HTTP GET manualmente a un servidor. Normalmente, utilizaría una interfaz de
HttpConnection, que construye la cadena del comando HTTP según las opciones que configure.
PRECAUCIÓN: Las operaciones de entrada y salida de red no son seguras para subprocesos. Aségurese de que crea
un subproceso separado cuando utilice un objeto de Connection.
Antes de comenzar: Abra una conexión de red y pase un objeto de Connection al constructor de la clase desarrollada
en esta tarea. Para obtener más información acerca de cómo abrir conexiones a la red, consulte "Abrir una conexión
de red mediante la API de red" o "Abrir una conexión de red mediante el GCF".

import net.rim.device.api.ui.container.MainScreen;
import net.rim.device.api.ui.component.RichTextField;
import java.io.InputStream;
import java.io.OutputStream;
2. Cree una clase que amplíe la clase MainScreen.
public class HTTPOutputScreen extends MainScreen
{
3. Cree una variable de la instancia para un objeto de RichTextField para mostrar los resultados.
RichTextField _rtfOutput = new RichTextField();
4. Cree a un constructor que acepte un objeto de Connection como argumento.
public HTTPOutputScreen(Connection conn)
{
5. Añada el RichTextField a su pantalla, e inicie un subproceso para acceder a la conexión de red.
_rtfOutput.setText("Retrieving data. Please wait...");
add(_rtfOutput);
ContentReaderThread t = new ContentReaderThread(conn);
t.start();
6. Cree un método para rellenar su RichTextField con los datos que devuelve el sitio Web, después de que
ContentReaderThread se complete. Se invoca este método en el paso 20.
public void showContents(final String result)

{
UiApplication.getUiApplication().invokeLater(new Runnable() {
public void run() {
_rtfOutput.setText(result);
25
}
});
}
7. En una clase interna, cree un subproceso para que se comunique con el servidor Web. Acepte un objeto de
ConnectionDescriptor como argumento.
private final class ContentReaderThread extends Thread

{
private Connection _connection;
ContentReaderThread(Connection conn)
{
_connection = conn;
}
public void run()
{
8. Inicialice un objeto de OutputStream y un objeto de InputStream para intercambiar los datos con el sitio
Web.
OutputStream os = null;
InputStream is = null;
9. Inicialice un objeto de String para almacenar la respuesta del sitio Web.
String result = "";
10. Cree un objeto de OutputConnection para enviar los datos por su conexión.
try
{
OutputConnection outputConn = (OutputConnection) connection;
11. Recupere un OutputStream de su OutputConnection.
os = outputConn.openOutputStream();
String getCommand = "GET " + "/" + " HTTP/1.0\r\n\r\n";
os.write(getCommand.getBytes());
os.flush();
12. Envíe un comando HTTP GET al servidor Web sobre su OutputStream. Convierta el comando GET en una matriz
de byte.
os.flush();
13. Cree un objeto de InputConnection para recibir los datos de su conexión.
InputConnection inputConn = (InputConnection) connection;
14. Recupere un InputStream de su InputConnection.
is = inputConn.openInputStream();
15. Recupere los datos transferidos y almacénelos en una matriz de byte.
26
byte[] data = net.rim.device.api.io.IOUtilities.streamToBytes(is);

result = new String(data);
16. Revise cualquier error que pueda generar su procedimiento.
catch(Exception e)
{
result = "ERROR fetching content: " + e.toString();
}
17. Cierre su OutputStream.
if(os != null)
{
try
{
os.close();
}
catch(IOException e)
{
// process the error condition
}
}
18. Cierre su InputStream.
if(is != null)
{
try
{
is.close();
}
{
}
}
19. Cierre su Connection.
{
connection.close();
}
catch(IOException ioe)
{
}
}
20. Llame al showContents() que creó en el paso 6.
showContents(result);
}
}
27
Guía de desarrollo Opciones de transporte de red
Opciones de transporte de red

Transporte Información adicional
TCP móvil Cuando crea una conexión mediante transporte TCP móvil, puede que necesite
especificar los parámetros siguientes:
• APN
• Nombre de usuario de autorización de túnel
• Contraseña de autorización de túnel
Si es mediante la API de red, puede utilizar la clase de TCPCellularOptions
para configurar estas opciones. Para dispositivos BlackBerry® ® que ejecutan
BlackBerry® 6 y posterior, puede determinar si estas opciones ya están
establecidas invocando TCPCellularOptions.isDefaultAPNSet().
Si está usando el GCF, podría utilizar una cadena de conexión semejante a la
siguiente:
"http://www.blackberry.com;deviceside=true;
apn=carriergateway;TunnelAuthusername=GW@CARRIERGPRS.COM;
TunnelAuthPassword=CARRIER"
TCP Wi-Fi® Si está usando el GCF, puede utilizar el transporte Wi-Fi® con una cadena de
conexión semejante a la siguiente:
"http://www.blackberry.com;interface=wifi"
WAP 2.0 Si WAP 2.0 está configurado en un dispositivo, necesita obtener un identificador
de conexión del libro de servicios. Si está usando el GCF, podría utilizar una cadena
de conexión semejante a la siguiente:
"http://www.blackberry.com;deviceside=true;ConnectionUID=H6Q1234"
Para obtener más información acerca de cómo recuperar un identificador de
conexión, consulte el artículo de la base de conocimientos en http://
supportforums.blackberry.com/t5/Java-Development/What-Is-Network-API-
alternative-for-legacy-OS/ta-p/614822
WAP 1.0 y 1.1 Como con TCP móvil, puede que necesite especificar parámetros adicionales para
utilizar el gateway de WAP 1.0 o 1.1:
• Gateway APN
• Dirección IP de gateway
• Puerto de gateway
• Dirección IP de origen
• Puerto de origen
• Nombre de usuario de autorización de túnel
28
Guía de desarrollo Opciones de transporte de red
Transporte Información adicional

• Contraseña de autorización de túnel
• Activar WTLS
Si está usando la API de red, puede utilizar la clase de WapOptions para configurar
estas opciones.
Si está usando el GCF, podría utilizar una cadena de conexión semejante a la
siguiente:
“http://www.blackberry.com;deviceside=true;
WapGatewayIP=127.0.0.1;WapGatewayPort:9201; WapGatewayAPN =
carriergateway"
BlackBerry® Mobile Data Si está usando el GCF, puede utilizar el transporte de BlackBerry MDS con una
System cadena de conexión semejante a la siguiente:
"http://www.blackberry.com;deviceside=false"
BlackBerry® Internet Service Para utilizar el transporte de BlackBerry Internet Service, debe suscribirse a
BlackBerry® Push Service. Para obtener más información, visite http://
na.blackberry.com/eng/developers/javaappdev/pushapi.jsp
29
Guía de desarrollo Trabajar con radios
Trabajar con radios 5

Es posible que haya los casos en los que deba encender una radio en un dispositivo BlackBerry® para utilizar un
transporte de red específico. Por ejemplo, puede que quiera que su aplicación para dispositivos BlackBerry se conecte
a través de Wi-Fi® hacer un uso eficaz del ancho de banda. O puede que quiera comparar el rendimiento de su
aplicación cuando utilice tecnologías inalámbricas diferentes.
Puede utilizar la clase de net.rim.device.api.system.RadioInfo para reunir información sobre las
tecnologías inalámbricas disponibles en un dispositivo. Mediante la clase de rim.device.api.system.Radio,
puede administrar las radios del dispositivo. También debe implementar la interfaz de
net.rim.device.api.system.RadioStatusListener para recibir notificaciones acerca de cambios en el
estado de la radio.
Las tecnologías inalámbricas disponibles en los dispositivos BlackBerry se agrupan en tres familias de acceso
inalámbrico.
Familia de acceso inalámbrico Descripción

3GPP® Esta familia incluye GPRS, EDGE, UMTS®, GERAN, UTRAN y GAN.
CDMA Esta familia incluye CDMA2000® y EVDO.
WLAN Esta familia incluye IEEE® 802.11 ™, 802.11a, 802.11b y 802.11g.
Consultar la disponibilidad de la radio y cambiar su estado

Puede utilizar el RadioInfo y las clases de Radio para determinar si se admite una tecnología particular de radio
en un dispositivo BlackBerry® y para encender o apagar la radio. Para obtener más información, consulte la
documentación sobre API para BlackBerry® Java® SDK.
import net.rim.device.api.system.Radio;
import net.rim.device.api.system.RadioInfo;
2. Recupere un campo de bits de familias de acceso inalámbrico admitidas.
int intSupportedWAFs = RadioInfo.getSupportedWAFs();
3. Compruebe si la familia de acceso inalámbrico que quiere utilizar está disponible en el dispositivo. Realice un
orden de bits Y una operación que combine el campo de bits de intSupportedWAFs y la constante para la
familia de acceso inalámbrico que quiere utilizar. Si la familia está disponible, el resultado será distinto a cero.
if ((intSupportedWAFs & RadioInfo.WAF_WLAN) !=0 )
{
4. Recupere un campo de bits de radios disponibles.
int intSupportedWAFs = RadioInfo.getSupportedWAFs();
int intActiveWAFs = RadioInfo.getActiveWAFs();
30
Guía de desarrollo Consultar la disponibilidad de la radio y cambiar su estado
5. Compruebe si la radio que quiere utilizar está desactivada. Si lo está, se aplican un orden de bits Y una operación
a intActiveWAFs y la constante para la radio devuelve 0.
if ((intActiveWAFs & RadioInfo.WAF_WLAN) = 0)
{
6. Si la radio está desactivada, actívela.
Radio.activateWAFs(RadioInfo.WAF_WLAN);
}
}
31
Guía de desarrollo Ejemplos de código
Ejemplos de código 6
Muestra de código: solicitar datos mediante un objeto
BlockingSenderDestination
import net.rim.device.api.ui.*;
import net.rim.device.api.ui.component.*;
import net.rim.device.api.ui.container.*;
import java.io.*;
public class NetworkSample extends UiApplication
{
public static void main(String[] args)
{
NetworkSample app = new NetworkSample();
app.enterEventDispatcher();
}
public NetworkSample()
{
pushScreen(new BlockingSenderSample());
}
}
class BlockingSenderSample extends MainScreen implements FieldChangeListener
{
ButtonField _btnBlock = new ButtonField(Field.FIELD_HCENTER);
private static UiApplication _app = UiApplication.getUiApplication();
private String _result;
public BlockingSenderSample()
{
_btnBlock.setChangeListener(this);
_btnBlock.setLabel("Fetch page");
add(_btnBlock);
}
public void fieldChanged(Field button, int unused)
{
if(button == _btnBlock)
{
{
public void run()
{
String uriStr = "http://www.blackberry.com";
try
{
("CommAPISample", URI.create(uriStr));
if(bsd == null)
{
bsd =
32
Guía de desarrollo Muestra de código: solicitar datos mediante un objeto BlockingSenderDestination
DestinationFactory.createBlockingSenderDestination
(new Context("CommAPISample"),
URI.create(uriStr)
);
}
// Send message and wait for response
if(response != null)
{
BSDResponse(response);
}
}
catch(Exception e)
{
}
finally
{
if(bsd != null)
{
bsd.release();
}
}
}
});
t.start();
}
}
private void BSDResponse(Message msg)
{
if (msg instanceof ByteMessage)
{
ByteMessage reply = (ByteMessage) msg;
_result = (String) reply.getStringPayload();
} else if(msg instanceof StreamMessage)
{
StreamMessage reply = (StreamMessage) msg;
byte[] data = null;
try {
} catch (IOException e) {
}
if(data != null)
{
_result = new String(data);
}
}
_app.invokeLater(new Runnable() {
public void run() {
_app.pushScreen(new HTTPOutputScreen(_result));
}
});
}
}
33
Guía de desarrollo Muestra de código: solicitar datos mediante un objeto NonBlockingSenderDestination
class HTTPOutputScreen extends MainScreen

{
public HTTPOutputScreen(String message)
{
add(_rtfOutput);
showContents(message);
}
// After the data has been retrieved, display it
{
{
public void run()
{
}
});
}
}
Muestra de código: solicitar datos mediante un objeto

NonBlockingSenderDestination
import net.rim.device.api.ui.*
import net.rim.device.api.ui.component.ButtonField;
import net.rim.device.api.system.Application;
import java.io.*;
{
{
}
{
pushScreen(new NonBlockingSenderSample());
}
}
class NonBlockingSenderSample extends MainScreen
implements FieldChangeListener
{
ButtonField _btnNonBlock = new ButtonField(Field.FIELD_HCENTER);
public NonBlockingSenderSample()
{
_btnNonBlock.setChangeListener(this);
_btnNonBlock.setLabel("Fetch page");
34
Guía de desarrollo Muestra de código: solicitar datos mediante un objeto NonBlockingSenderDestination
add(_btnNonBlock);
}
{
if(button == _btnNonBlock)
{
NonBlockingSenderDestination destination = null;
try
{
URI uri = URI.create("http://www.blackberry.com");
NBSDMsgListener responseListener = new NBSDMsgListener();
destination = (NonBlockingSenderDestination)
("CommAPISample", uri);
if (destination == null)
{
destination =
DestinationFactory.createNonBlockingSenderDestination
(new Context("CommAPISample"), uri, responseListener);
}
// Send message to retrieve the response
destination.send();
}
catch(Exception e)
{
}
}
}
}
class NBSDMsgListener implements MessageListener
{
public void onMessage(Destination dest, Message msg)
{
String payload = null;
if (msg instanceof ByteMessage)
{
ByteMessage reply = (ByteMessage) msg;
payload = (String) reply.getStringPayload();
} else if(msg instanceof StreamMessage)
{
StreamMessage reply = (StreamMessage) msg;
byte[] data = null;
try {
}
if(data != null)
{
payload = new String(data);
}
}
if(payload!=null)
{
synchronized(Application.getEventLock())
35
Guía de desarrollo Muestra de código: análisis de una estructura de datos de JSON
{
UiApplication.getUiApplication().pushScreen
(new HTTPOutputScreen(payload));
}
}
}
public void onMessageCancelled(Destination arg0, int arg1)
{
// process message cancelled notification
}
public void onMessageFailed(Destination arg0, MessageFailureException arg1)
{
// process message failed notification
}
}
{
public HTTPOutputScreen(String message)
{
add(_rtfOutput);
showContents(message);
}
public void showContents(final String result) {
{
public void run()
{
}
});
}
}
Muestra de código: análisis de una estructura de datos de

JSON
La muestra de código siguiente muestra una forma de analizar una estructura de datos de JSON. Puede utilizar un
proceso semejante para analizar datos de JSON u otros formatos ofrecidos por la API de procesamiento de mensajes.
import net.rim.device.api.ui.*
import java.io.*;
import org.json.me.*;
{
{
36

}
{
pushScreen(new ParseJSONSample());
}
}
class ParseJSONSample extends MainScreen implements FieldChangeListener
{
ButtonField _btnJSON = new ButtonField(Field.FIELD_HCENTER);
public ParseJSONSample()
{
_btnJSON.setChangeListener(this);
_btnJSON.setLabel("Fetch page");
add(_btnJSON);
}
{
if(button == _btnJSON)
{
{
public void run()
{
String uriStr = "http://docs.blackberry.com/sampledata.json";
try
{
("CommAPISample", URI.create(uriStr));
if(bsd == null)
{
bsd =
DestinationFactory.createBlockingSenderDestination
(new Context("CommAPISample"),
URI.create(uriStr), new JSONMessageProcessor()
);
}
// Send message and wait for response
_json = response.getObjectPayload();
if(_json != null)
{
_app.invokeLater(new Runnable()
{
public void run()
{
_app.pushScreen(new JSONOutputScreen(_json));
}
});
}
}
37
catch(Exception e)
{
System.out.println(e.toString());
}
finally
{
if(bsd != null)
{
bsd.release();
}
}
}
});
t.start();
}
}
class JSONOutputScreen extends MainScreen implements TreeFieldCallback
{
private TreeField _treeField;
public JSONOutputScreen(Object JSONData)
{
_treeField = new TreeField(this, Field.FOCUSABLE);
add(_treeField);
setTree(JSONData);
}
void setTree(Object obj)
{
int parentNode = 0;
_treeField.deleteAll();
try
{
if(obj instanceof JSONArray)
{
parentNode = populateTreeArray
(_treeField, (JSONArray) obj, parentNode);
}
else if(obj instanceof JSONObject)
{
parentNode = populateTreeObject
(_treeField, (JSONObject) obj, parentNode);
}
}
catch(JSONException e)
{
System.out.println(e.toString());
}
_treeField.setCurrentNode(parentNode);
}
// Populate the trees with JSON arrays
int populateTreeArray(TreeField tree, JSONArray o, int p) throws JSONException
{
Object temp;
int newParent;
newParent = tree.addChildNode(p, "Array " + p);
for(int i = 0; i < o.length(); ++i)
{
38
temp = o.get(i);
if(temp == null || temp.toString().equalsIgnoreCase("null"))
{
continue;
}
if(temp instanceof JSONArray)
{
// Array of arrays
populateTreeArray(tree, (JSONArray) temp, newParent);
}
else if(temp instanceof JSONObject)
{
// Array of objects
populateTreeObject(tree, (JSONObject) temp, newParent);
}
else
{ // other values
newParent = tree.addSiblingNode(newParent, temp.toString());
}
}
return newParent;
}
// Populate the tree with JSON objects
int populateTreeObject(TreeField tree, JSONObject o, int p) throws JSONException
{
Object temp;
int newParent = tree.addChildNode(p, "Object" + p);
JSONArray a = o.names();
for(int i = 0; i < a.length(); ++i)
{
temp = o.get(a.getString(i));
if(temp == null || temp.toString().equalsIgnoreCase("null"))
{
continue;
}
if(temp instanceof JSONArray)
{
populateTreeArray(tree, (JSONArray) temp, newParent);
}
else if(temp instanceof JSONObject)
{
populateTreeObject(tree, (JSONObject) temp, newParent);
}
else
{
tree.addSiblingNode
(newParent, a.getString(i) + ": " + temp.toString());
}
}
return newParent;
}
public void drawTreeItem(TreeField treeField, Graphics graphics, int node,
int y, int width, int indent)
{
if(treeField == _treeField)
{
39
Guía de desarrollo Muestra de código: recuperar una página Web mediante el API de red
Object cookie = _treeField.getCookie(node);

if(cookie instanceof String)
{
String text = (String) cookie;
graphics.drawText(text, indent, y, Graphics.ELLIPSIS, width);
}
}
}
public boolean onSavePrompt()
{
// Suppress the save dialog
return true;
}
}
Muestra de código: recuperar una página Web mediante el

API de red
Para hacer esta muestra de código tan genérica como sea posible, se usan las interfaces de InputConnection y
OutputConnection en lugar de la de HttpConnection.
import net.rim.device.api.io.transport.options.*;
import net.rim.device.api.util.Arrays;
import java.io.*;
{
{
}
{
new HTTPConnectionSetup();
}
}
class HTTPConnectionSetup
{
ConnectionFactory _factory = new ConnectionFactory();
public HTTPConnectionSetup()
{
// Create preference ordered list of transports
int[] _intTransports =
{ TransportInfo.TRANSPORT_TCP_WIFI,
TransportInfo.TRANSPORT_WAP2,
TransportInfo.TRANSPORT_TCP_CELLULAR
};
// Remove any transports that are not (currently) available
40
for(int i = 0; i < _intTransports.length ; i++)

{
int transport = _intTransports[i];
if(!TransportInfo.isTransportTypeAvailable(transport)
|| !TransportInfo.hasSufficientCoverage(transport))
{
Arrays.removeAt(_intTransports, i);
}
}
// Set options for TCP Cellular transport
TcpCellularOptions tcpOptions = new TcpCellularOptions();
if(!TcpCellularOptions.isDefaultAPNSet())
{
tcpOptions.setApn("My APN");
tcpOptions.setTunnelAuthUsername("user");
tcpOptions.setTunnelAuthPassword("password");
}
// Set ConnectionFactory options
if(_intTransports.length > 0)
{
_factory.setPreferredTransportTypes(_intTransports);
}
_factory.setTransportTypeOptions(TransportInfo.TRANSPORT_TCP_CELLULAR,
tcpOptions);
_factory.setAttemptsLimit(5);
// Open a connection on a new thread
{
public void run()
{
ConnectionDescriptor cd = _factory.getConnection
("http://www.blackberry.com");
// If connection was successful, fetch and show the content from
// the web server
if(cd != null)
{
Connection c = cd.getConnection();
displayContent(c);
}
}
});
t.start();
}
{
// When the connection thread completes, show the data from the web server
{
public void run()
{
}
});
}
}
41
{
{
// Create a container for the data, and put it on the screen
add(_rtfOutput);
// Retrieve the data from the web server, using the connection, on a
// separate thread
t.start();
}
{
{
public void run()
{
}
});
}
{
{
_connection = conn;
}
public void run()
{
String result = "";
try
{
// Send HTTP GET to the server
OutputConnection outputConn = (OutputConnection) _connection;
os.flush();
// Get InputConnection and read the server's response
InputConnection inputConn = (InputConnection) _connection;
// is.close();
}
catch(Exception e)
{
}
finally
{
42
Guía de desarrollo Muestra de código: recuperar una página Web mediante el GCF
// Close OutputStream
if(os != null)
{
try
{
os.close();
}
{
}
}
// Close InputStream
if(is != null)
{
try
{
is.close();
}
{
}
}
// Close Connection
try
{
_connection.close();
}
{
}
}
// Show the response received from the web server, or an error message
}
}
}
Muestra de código: recuperar una página Web mediante el

GCF
Esta muestra de código utiliza el transporte BlackBerry® Mobile Data System. Para hacer esta muestra de código tan
genérica como sea posible, se usan las interfaces de InputConnection y OutputConnection en lugar de la de
HttpConnection.
import java.io.*;
{
43
{
}
public NetworkSample() {
new HTTPConnectionSetup();
}
}
class HTTPConnectionSetup
{
public HTTPConnectionSetup()
{
{
public void run() {
Connection c = null;
try
{
c = Connector.open("http://www.blackberry.com;deviceside=false");
e.printStackTrace();
}
if(c != null)
{
displayContent(c);
}
}
});
t.start();
}
private void displayContent(final Connection c) {
// When the connection thread completes, show the data from the web server
{
public void run() {
UiApplication.getUiApplication().pushScreen(new HTTPOutputScreen(c));
}
});
}
}
{
{
// Create a container for the data, and put it on the screen
add(_rtfOutput);
// Retrieve the data from the web server, using the connection, on a
// separate thread
t.start();
}
{
44
{
public void run()
{
}
});
}
{
{
_connection = conn;
}
public void run()
{
String result = "";
try
{
// Send HTTP GET to the server
OutputConnection outputConn = (OutputConnection) _connection;
os.flush();
// Get InputConnection and read the server's response
InputConnection inputConn = (InputConnection) _connection;
// is.close();
}
catch(Exception e)
{
}
finally
{
// Close OutputStream
if(os != null)
{
try
{
os.close();
}
{
}
}
// Close InputStream
if(is != null)
{
try
45
Guía de desarrollo Muestra de código: determinar los transportes de red con cobertura suficiente mediante la API de
red
{
is.close();
}
{
}
}
// Close Connection
try
{
_connection.close();
}
{
}
}
// Show the response received from the web server, or an error message
}
}
}
Muestra de código: determinar los transportes de red con

cobertura suficiente mediante la API de red
{
{
}
public NetworkSample() {
pushScreen(new ListTransportsWithCoverageScreen());
}
}
class ListTransportsWithCoverageScreen extends MainScreen
{
private int[] _transportsWithCoverage;
private TransportDescriptor[] _transports;
private RichTextField _rtfDisplay;
private ButtonField _btnShowTransports;
public ListTransportsWithCoverageScreen()
{
VerticalFieldManager vfm = new VerticalFieldManager();
setTitle("Network Sample");
_rtfDisplay = new RichTextField
("Click button below to display available transports.");
_btnShowTransports = new ButtonField
46
Guía de desarrollo Muestra de código: control de radios
("Show Transports", Field.FIELD_HCENTER);

_btnShowTransports.setChangeListener(new FieldChangeListener()
{
public void fieldChanged(Field field, int context)
{
getTransports();
}
});
vfm.add(_rtfDisplay);
vfm.add(_btnShowTransports);
add(vfm);
}
public void getTransports()
{
StringBuffer sb = new StringBuffer();
sb.append("The transports currently available are: \n");
_transportsWithCoverage = TransportInfo.getCoverageStatus();
_transports = TransportInfo.getTransportDescriptors
(_transportsWithCoverage);
for(int i = _transports.length - 1; i >=0; --i)
{
switch(_transports[i].getTransportType())
{
case TransportInfo.TRANSPORT_BIS_B:
sb.append("BlackBerry Internet Service\n");
break;
case TransportInfo.TRANSPORT_MDS:
sb.append("BlackBerry Mobile Data Service\n");
break;
case TransportInfo.TRANSPORT_TCP_CELLULAR:
sb.append("TCP Cellular\n");
break;
case TransportInfo.TRANSPORT_TCP_WIFI:
sb.append("TCP WiFi\n");
break;
case TransportInfo.TRANSPORT_WAP:
sb.append("WAP 1.0 or 1.1\n");
break;
case TransportInfo.TRANSPORT_WAP2:
sb.append("WAP 2.0\n");
break;
}
}
_rtfDisplay.setText(sb.toString());
}
}
Muestra de código: control de radios

import net.rim.device.api.system.*;
public class NetworkSample extends UiApplication {
47

{
}
{
pushScreen(new RadioControlScreen());
}
}
class RadioControlScreen extends MainScreen implements FieldChangeListener
{
boolean[] _intRadioOn = new boolean[3];
ButtonField _btn3G, _btnCDMA, _btniDEN, _btnWiFi;
public RadioControlScreen()
{
VerticalFieldManager vfm = new VerticalFieldManager(Field.FIELD_HCENTER);
int wafs = RadioInfo.getSupportedWAFs();
if ((wafs & RadioInfo.WAF_3GPP) != 0 )
{
_btn3G = new ButtonField("3G Radio");
_btn3G.setChangeListener(this);
vfm.add(_btn3G);
}
if ((wafs & RadioInfo.WAF_CDMA) != 0 )
{
_btnCDMA = new ButtonField("CDMA Radio");
_btnCDMA.setChangeListener(this);
vfm.add(_btnCDMA);
}
if ((wafs & RadioInfo.WAF_WLAN) != 0 )
{
_btnWiFi = new ButtonField("WiFi Radio");
_btnWiFi.setChangeListener(this);
vfm.add(_btnWiFi);
}
wafs = RadioInfo.getActiveWAFs();
if ((wafs & RadioInfo.WAF_3GPP) != 0 )
{
_intRadioOn[0] = true;
_btn3G.setLabel("3G Radio is on");
}
if ((wafs & RadioInfo.WAF_CDMA) != 0 )
{
_btnCDMA.setLabel("CDMA Radio is on");
}
if ((wafs & RadioInfo.WAF_WLAN) != 0 )
{
_btnWiFi.setLabel("WiFi Radio is on");
}
add(vfm);
StandardTitleBar tb = new StandardTitleBar();
tb.addTitle("Radio Control Demo");
tb.addSignalIndicator();
48
setTitleBar(tb);
}
{
if (field instanceof ButtonField)
{
if(field == _btn3G)
{
if (_intRadioOn[0])
{
Radio.deactivateWAFs(RadioInfo.WAF_3GPP);
_btn3G.setLabel("3G Radio is off");
_intRadioOn[0] = false;
} else
{
Radio.activateWAFs(RadioInfo.WAF_3GPP);
_btn3G.setLabel("3G Radio is on");
}
} else if(field == _btnCDMA)
{
if (_intRadioOn[1])
{
Radio.deactivateWAFs(RadioInfo.WAF_CDMA);
_btnCDMA.setLabel("CDMA Radio is off");
} else
{
Radio.activateWAFs(RadioInfo.WAF_CDMA);
_btnCDMA.setLabel("CDMA Radio is on");
}
} else if(field == _btnWiFi)
{
if (_intRadioOn[2])
{
Radio.deactivateWAFs(RadioInfo.WAF_WLAN);
_btnWiFi.setLabel("WiFi Radio is off");
} else
{
Radio.activateWAFs(RadioInfo.WAF_WLAN);
_btnWiFi.setLabel("WiFi Radio is on");
}
}
}
}
}
49
Guía de desarrollo Muestra de código: determinar el estado de un transporte de red mediante la API de red
Muestra de código: determinar el estado de un transporte

de red mediante la API de red
import net.rim.device.api.io.transport.TransportInfo;
{
{
}
{
pushScreen(new ProbeSpecificTransportScreen());
}
}
class ProbeSpecificTransportScreen extends MainScreen implements FieldChangeListener {
private TextField _tfTransportStatus;
private ObjectChoiceField _ocfTransports;
public ProbeSpecificTransportScreen()
{
String[] strTransportNames =
{"none", "TCP Cellular", "WAP 1.0/1.1",
"WAP 2.0", "MDS", "BIS", "TCP WiFi"
};
VerticalFieldManager vfm = new VerticalFieldManager();
_tfTransportStatus = new TextField(Field.FIELD_HCENTER);
_tfTransportStatus.setText
("Select a transport from the list above, then click 'Probe Transport'");
_ocfTransports = new ObjectChoiceField
("Select Transport to Probe: ", strTransportNames,
0, Field.FIELD_HCENTER);
_ocfTransports.setEditable(true);
ButtonField btnProbe = new ButtonField("Probe Transport", Field.FIELD_HCENTER);
btnProbe.setChangeListener(this);
vfm.add(_ocfTransports);
vfm.add(btnProbe);
vfm.add(_tfTransportStatus);
add(vfm);
}
{
int intTransportType = _ocfTransports.getSelectedIndex();
if(intTransportType > 0)
{
if(TransportInfo.isTransportTypeAvailable(intTransportType))
{
if(TransportInfo.hasSufficientCoverage(intTransportType))
{
50
Guía de desarrollo Muestra de código: determinar el estado de un transporte de red mediante la API de red
((String)_ocfTransports.getChoice(intTransportType)
+ " is available.");
} else
{
((String)_ocfTransports.getChoice(intTransportType)
+ " is available but has insufficient coverage.");
}
} else
{
_tfTransportStatus.setText("Sorry, " +
(String)_ocfTransports.getChoice(intTransportType)
+ " is not available.");
}
} else
{
("Please select a transport first, then click 'Probe Transport'");
}
}
}
51
Guía de desarrollo Glosario
Glosario 7
3GPP
Third Generation Partnership Project (Proyecto de asociación de tercera generación)
AES
Advanced Encryption Standard (Estándar de cifrado avanzado)
API
Application Programming Interface (Interfaz de programación de aplicaciones)
APN
access point name (nombre de punto de acceso)
BlackBerry MDS
BlackBerry® Mobile Data System
CDMA
Code Division Multiple Access (Acceso múltiple por división de códigos)
EDGE
Enhanced Data Rates for Global Evolution (Velocidad de datos mejorada para una evolución global)
EVDO
Evolution Data Optimized (Datos de evolución optimizada)
GAN
red de acceso genérico
GERAN
Red de acceso radio para GSM-EDGE
GCF
Marco genérico de conexión (GCF)
GPRS
General Packet Radio Service
GSM
Global System for Mobile Communications® (Sistema global para comunicaciones móviles)
HTTP
Hypertext Transfer Protocol (Protocolo de transferencia de hipertexto)
52
HTTPS
Hypertext Transfer Protocol over Secure Sockets Layer (Protocolo de transferencia de hipertexto a través de un
nivel de socket seguro)
IP
Protocolo de Internet (Internet Protocol)
JSON
JavaScript Object Notation (Notación de Objetos de JavaScript)
RDF
Resource Description Framework (Marco de descripción de recursos)
RSS
Really Simple Syndication
SOAP
Protocolo de acceso simple a objetos
SSL
Secure Sockets Layer (Capa de sockets seguros)
TCP
Transmission Control Protocol (Protocolo de control de transmisión)
TLS
Transport Layer Security (Seguridad de capa de transporte)
Triple DES
Triple Data Encryption Standard (Estándar de cifrado triple de datos)
UDP
User Datagram Protocol (Protocolo del datagrama de usuario)
URI
Uniform Resource Identifier (Identificador uniforme de recursos)
URL
Uniform Resource Locator (Localizador uniforme de recursos)
UMTS
Universal Mobile Telecommunications System (Sistema Universal de Telecomunicaciones Móviles)
UTRAN
53
Red de acceso radio terrestre para UMTS
VPN
Virtual Private Network (Red privada virtual)
WAP
Wireless Application Protocol (Protocolo de aplicaciones inalámbricas)
WLAN
wireless local area network (red inalámbrica de área local)
WTLS
Wireless Transport Layer Security (Seguridad inalámbrica de la capa de transporte)
XML
Extensible Markup Language (Lenguaje de marcado extensible)
54
Guía de desarrollo Comentarios
Comentarios 8
Para ofrecer comentarios acerca de esta entrega, visite www.blackberry.com/docsfeedback.
55
Guía de desarrollo Historial de revisión del documento
Historial de revisión del documento 9

Fecha Descripción
8 Noviembre de 2010 Se cambiaron los temas siguientes:
• Arquitectura: transportes de red
• Comunicar con servidores HTTP
• Opciones de transportes de red
27 Septiembre de 2010 Primer borrador publicado.
56
Guía de desarrollo Aviso legal
Aviso legal 10
©2011 Research In Motion Limited. Reservados todos los derechos. BlackBerry®, RIM®, Research In Motion® y las
marcas comerciales, nombres y logotipos relacionados son propiedad de Research In Motion Limited y están
registrados y/o se usan en EE. UU. y en diferentes países del mundo.
3GPP yUMTS son marcas comerciales del European Telecommunications Standard Institute. Java y JavaScript son
marcas comerciales de Oracle America, Inc. CDMA2000 es una marca comercial de Telecommunications Industry
Association. Wi-Fi es una marca comercial de Wi-Fi Alliance.. Todas las demás marcas comerciales son propiedad de
sus respectivos propietarios.
Esta documentación, incluida cualquier documentación que se incorpore mediante referencia como documento
proporcionado o disponible en www.blackberry.com/go/docs se proporciona o se pone a disposición "TAL CUAL" y
"SEGÚN SU DISPONIBILIDAD" sin ninguna condición, responsabilidad o garantía de ningún tipo por Research In Motion
Limited y sus empresas afiliadas ("RIM") y RIM no asume ninguna responsabilidad por los errores tipográficos,
técnicos o cualquier otra imprecisión, error u omisión contenidos en esta documentación. Con el fin de proteger la
información confidencial y propia de RIM, así como los secretos comerciales, la presente documentación describe
algunos aspectos de la tecnología de RIM en líneas generales. RIM se reserva el derecho a modificar periódicamente
la información que contiene esta documentación, si bien tampoco se compromete en modo alguno a proporcionar
cambios, actualizaciones, ampliaciones o cualquier otro tipo de información que se pueda agregar a esta
documentación.
Esta documentación puede contener referencias a fuentes de información, hardware o software, productos o
servicios, incluidos componentes y contenido como, por ejemplo, el contenido protegido por copyright y/o sitios
Web de terceros (conjuntamente, los "Productos y servicios de terceros"). RIM no controla ni es responsable de
ningún tipo de Productos y servicios de terceros, incluido, sin restricciones, el contenido, la exactitud, el cumplimiento
de copyright, la compatibilidad, el rendimiento, la honradez, la legalidad, la decencia, los vínculos o cualquier otro
aspecto de los Productos y servicios de terceros. La inclusión de una referencia a los Productos y servicios de terceros
en esta documentación no implica que RIM se haga responsable de dichos Productos y servicios de terceros o de
dichos terceros en modo alguno.
EXCEPTO EN LA MEDIDA EN QUE LO PROHÍBA ESPECÍFICAMENTE LA LEY DE SU JURISDICCIÓN, QUEDAN EXCLUIDAS
POR LA PRESENTE TODAS LAS CONDICIONES, APROBACIONES O GARANTÍAS DE CUALQUIER TIPO, EXPLÍCITAS O
IMPLÍCITAS, INCLUIDA, SIN NINGÚN TIPO DE LIMITACIÓN, CUALQUIER CONDICIÓN, APROBACIÓN, GARANTÍA,
DECLARACIÓN DE GARANTÍA DE DURABILIDAD, IDONEIDAD PARA UN FIN O USO DETERMINADO, COMERCIABILIDAD,
CALIDAD COMERCIAL, ESTADO DE NO INFRACCIÓN, CALIDAD SATISFACTORIA O TITULARIDAD, O QUE SE DERIVE DE
UNA LEY O COSTUMBRE O UN CURSO DE LAS NEGOCIACIONES O USO DEL COMERCIO, O RELACIONADO CON LA
DOCUMENTACIÓN O SU USO O RENDIMIENTO O NO RENDIMIENTO DE CUALQUIER SOFTWARE, HARDWARE,
SERVICIO O CUALQUIER PRODUCTO O SERVICIO DE TERCEROS MENCIONADOS AQUÍ. TAMBIÉN PODRÍA TENER OTROS
DERECHOS QUE VARÍAN SEGÚN EL ESTADO O PROVINCIA. ES POSIBLE QUE ALGUNAS JURISDICCIONES NO PERMITAN
LA EXCLUSIÓN O LA LIMITACIÓN DE GARANTÍAS IMPLÍCITAS Y CONDICIONES. EN LA MEDIDA EN QUE LO PERMITA
LA LEY, CUALQUIER GARANTÍA IMPLÍCITA O CONDICIONES EN RELACIÓN CON LA DOCUMENTACIÓN NO SE PUEDEN
EXCLUIR TAL Y COMO SE HA EXPUESTO ANTERIORMENTE, PERO PUEDEN SER LIMITADAS, Y POR LA PRESENTE ESTÁN
LIMITADAS A NOVENTA (90) DÍAS DESDE DE LA FECHA QUE ADQUIRIÓ LA DOCUMENTACIÓN O EL ELEMENTO QUE
ES SUJETO DE LA RECLAMACIÓN.
57
EN LA MEDIDA MÁXIMA EN QUE LO PERMITA LA LEY DE SU JURISDICCIÓN, EN NINGÚN CASO RIM ASUMIRÁ
RESPONSABILIDAD ALGUNA POR CUALQUIER TIPO DE DAÑOS RELACIONADOS CON ESTA DOCUMENTACIÓN O SU
USO, O RENDIMIENTO O NO RENDIMIENTO DE CUALQUIER SOFTWARE, HARDWARE, SERVICIO O PRODUCTOS Y
SERVICIOS DE TERCEROS AQUÍ MENCIONADOS INCLUIDOS SIN NINGÚN TIPO DE LIMITACIÓN CUALQUIERA DE LOS
SIGUIENTES DAÑOS: DIRECTOS, RESULTANTES, EJEMPLARES, INCIDENTALES, INDIRECTOS, ESPECIALES, PUNITIVOS
O AGRAVADOS, DAÑOS POR PÉRDIDA DE BENEFICIOS O INGRESOS, IMPOSIBILIDAD DE CONSEGUIR LOS AHORROS
ESPERADOS, INTERRUPCIÓN DE LA ACTIVIDAD COMERCIAL, PÉRDIDA DE INFORMACIÓN COMERCIAL, PÉRDIDA DE
LA OPORTUNIDAD DE NEGOCIO O CORRUPCIÓN O PÉRDIDA DE DATOS, IMPOSIBILIDAD DE TRANSMITIR O RECIBIR
CUALQUIER DATO, PROBLEMAS ASOCIADOS CON CUALQUIER APLICACIÓN QUE SE UTILICE JUNTO CON PRODUCTOS
Y SERVICIOS DE RIM, COSTES DEBIDOS AL TIEMPO DE INACTIVIDAD, PÉRDIDA DE USO DE LOS PRODUCTOS Y SERVICIOS
DE RIM O PARTE DE ÉL O DE CUALQUIER SERVICIO DE USO, COSTE DE SERVICIOS SUSTITUTIVOS, COSTES DE
COBERTURA, INSTALACIONES O SERVICIOS, COSTE DEL CAPITAL O CUALQUIER OTRA PÉRDIDA MONETARIA SIMILAR,
TANTO SI DICHOS DAÑOS SE HAN PREVISTO O NO, Y AUNQUE SE HAYA AVISADO A RIM DE LA POSIBILIDAD DE DICHOS
DAÑOS.
EN LA MEDIDA MÁXIMA EN QUE LO PERMITA LA LEY DE SU JURISDICCIÓN, RIM NO TENDRÁ NINGÚN OTRO TIPO DE
OBLIGACIÓN O RESPONSABILIDAD CONTRACTUAL, EXTRACONTRACTUAL O CUALQUIER OTRA, INCLUIDA CUALQUIER
RESPONSABILIDAD POR NEGLIGENCIA O RESPONSABILIDAD ESTRICTA.
LAS LIMITACIONES, EXCLUSIONES Y DESCARGOS DE RESPONSABILIDAD SE APLICARÁN: (A) INDEPENDIENTEMENTE
DE LA NATURALEZA DE LA CAUSA DE LA ACCIÓN, DEMANDA O ACCIÓN SUYA, INCLUIDA PERO NO LIMITADA AL
INCUMPLIMIENTO DEL CONTRATO, NEGLIGENCIA, AGRAVIO, EXTRACONTRACTUAL, RESPONSABILIDAD ESTRICTA O
CUALQUIER OTRA TEORÍA DEL DERECHO Y DEBERÁN SOBREVIVIR A UNO O MÁS INCUMPLIMIENTOS ESENCIALES O
AL INCUMPLIMIENTO DEL PROPÓSITO ESENCIAL DE ESTE CONTRATO O CUALQUIER SOLUCIÓN CONTENIDA AQUÍ; Y
(B) A RIM Y A SUS EMPRESAS AFILIADAS, SUS SUCESORES, CESIONARIOS, AGENTES, PROVEEDORES (INCLUIDOS LOS
PROVEEDORES DE SERVICIOS DE USO), DISTRIBUIDORES AUTORIZADOS POR RIM (INCLUIDOS TAMBIÉN LOS
PROVEEDORES DE SERVICIOS DE USO) Y SUS RESPECTIVOS DIRECTORES, EMPLEADOS Y CONTRATISTAS
INDEPENDIENTES.
ADEMÁS DE LAS LIMITACIONES Y EXCLUSIONES MENCIONADAS ANTERIORMENTE, EN NINGÚN CASO NINGÚN
DIRECTOR, EMPLEADO, AGENTE, DISTRIBUIDOR, PROVEEDOR, CONTRATISTA INDEPENDIENTE DE RIM O CUALQUIER
AFILIADO DE RIM ASUMIRÁ NINGUNA RESPONSABILIDAD DERIVADA DE O RELACIONADA CON LA DOCUMENTACIÓN.
Antes de instalar, usar o suscribirse a cualquiera de los Productos y servicios de terceros, es su responsabilidad
asegurarse de que su proveedor de servicios de uso ofrezca compatibilidad con todas sus funciones. Puede que
algunos proveedores de servicios de uso no ofrezcan las funciones de exploración de Internet con una suscripción
al servicio BlackBerry® Internet Service. Consulte con su proveedor de servicios acerca de la disponibilidad, arreglos
de itinerancia, planes de servicio y funciones. La instalación o el uso de los Productos y servicios de terceros con
productos y servicios de RIM puede precisar la obtención de una o más patentes, marcas comerciales, derechos de
autor u otras licencias para evitar que se vulneren o violen derechos de terceros. Usted es el único responsable de
determinar si desea utilizar Productos y servicios de terceros y si se necesita para ello cualquier otra licencia de
terceros. En caso de necesitarlas, usted es el único responsable de su adquisición. No instale o utilice Productos y
servicios de terceros hasta que se hayan adquirido todas las licencias necesarias. Cualquier tipo de Productos y
servicios de terceros que se proporcione con los productos y servicios de RIM se le facilita para su comodidad "TAL
CUAL" sin ninguna condición expresa e implícita, aprobación, garantía de cualquier tipo por RIM y RIM no sume
58
ninguna responsabilidad en relación con ello. El uso de los Productos y servicios de terceros se regirá y estará sujeto
a la aceptación de los términos de licencias independientes aplicables en este caso con terceros, excepto en los casos
cubiertos expresamente por una licencia u otro acuerdo con RIM.
Algunas funciones mencionadas en esta documentación requieren una versión mínima del software de BlackBerry®
Enterprise Server, BlackBerry® Desktop Software y/o BlackBerry® Device Software.
Los términos de uso de cualquier producto o servicio de RIM se presentan en una licencia independiente o en otro
acuerdo con RIM que se aplica en este caso. NINGUNA PARTE DE LA PRESENTE DOCUMENTACIÓN ESTÁ PENSADA
PARA PREVALECER SOBRE CUALQUIER ACUERDO EXPRESO POR ESCRITO O GARANTÍA PROPORCIONADA POR RIM
PARA PARTES DE CUALQUIER PRODUCTO O SERVICIO DE RIM QUE NO SEA ESTA DOCUMENTACIÓN.
Research In Motion Limited

295 Phillip Street
Waterloo, ON N2L 3W8
Canadá
Research In Motion UK Limited

Centrum House
36 Station Road
Egham, Surrey TW20 9LF
Reino Unido
Publicado en Canadá
59

Blackberry Java SDK 1327377 0217050809 005 6.0 ES (Network Communcation

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Blackberry Java SDK 1327377 0217050809 005 6.0 ES (Network Communcation

Hochgeladen von

Copyright:

Verfügbare Formate

BlackBerry Java SDK

5 Trabajar con radios........................................................................................................................................... 30

9 Historial de revisión del documento................................................................................................................. 56

Descripción general de comunicación de red 1

Comunicar con servidores HTTP

Si es necesario, puede conectar múltiples procesadores de mensajes. La clase de MessageProcessorChain

Solicitar datos mediante un objeto BlockingSenderDestination

Solicitar datos mediante un objeto NonBlockingSenderDestination

1. Importe las clases y las interfaces necesarias.

Después de terminar: Publique NonBlockingSenderDestination cuando acabe de procesar la respuesta.

Implementar la interfaz MessageListener

a. Si la respuesta es pequeña, convierta los contenidos de la transmisión en una matriz de byte.

7. Si payload contiene datos, muéstrelo.

Después de terminar: Implemente onMessageCancelled() y onMessageFailed() para procesar otras

Enviar datos mediante un objeto FireAndForgetDestination

8. Envíe el mensaje al servicio Web.

Analizar un formato de datos común de Internet

Suscribirse a un iniciador push

Suscribirse a un iniciador push

1. Importe las clases y las interfaces necesarias.

Enviar información de inicio de sesión a un servidor HTTP

context = new Context("DemoContext", new CredentialsCollector() {

Transporte de red Descripción

Transporte de red Descripción

Utilizar BlackBerry Enterprise Server como gateway de

Utilizar el gateway de Internet de un proveedor de servicios

Tipo de usuario Orden de transportes preferidos

Elegir transportes de red mediante la API de red

Abrir una conexión de red mediante la API de red

Abrir una conexión de red mediante la API de red

Marco genérico de conexión (GCF)

Abrir una conexión de red mediante el GCF

1. Importe las clases y las interfaces necesarias.

2. Cree un subproceso nuevo para abrir la conexión.

Enviar y recibir datos mediante una conexión de red

1. Importe las clases y las interfaces necesarias.

public void showContents(final String result)

private final class ContentReaderThread extends Thread

byte[] data = net.rim.device.api.io.IOUtilities.streamToBytes(is);

Opciones de transporte de red

Transporte Información adicional

Trabajar con radios 5

Familia de acceso inalámbrico Descripción

Consultar la disponibilidad de la radio y cambiar su estado

int intActiveWAFs = RadioInfo.getActiveWAFs();

class HTTPOutputScreen extends MainScreen

Muestra de código: solicitar datos mediante un objeto

Muestra de código: análisis de una estructura de datos de

NetworkSample app = new NetworkSample();

Object cookie = _treeField.getCookie(node);

Muestra de código: recuperar una página Web mediante el

for(int i = 0; i < _intTransports.length ; i++)

Muestra de código: recuperar una página Web mediante el

Muestra de código: determinar los transportes de red con

("Show Transports", Field.FIELD_HCENTER);

Muestra de código: control de radios

public static void main(String[] args)

Muestra de código: determinar el estado de un transporte

Red de acceso radio terrestre para UMTS

Historial de revisión del documento 9

Research In Motion Limited

Research In Motion UK Limited

Das könnte Ihnen auch gefallen