第7章 使用数据报（Datagram）连接

数据报连接

通过利用UDP（User Datagram Protocal，用户数据报协议），BlackBerry设备支持数据报连接。应用程序使用UDP和标准的网络服务通信。

数据报是应用程序发送到网络的独立数据包。对于Datagram的负载字节数组来说，一个Datagram对象是一个包装器。为获得这个字节数组的一个引用，调用getData()方法。

和HTTP连接不一样，数据报连接不稳定：数据包以任意的顺序到达，并且传输得不到保证。应用程序的责任是确保请求数据报的数据负载根据网络服务的标准来格式化，这个标准是在数据报传播上的。应用程序也必须能解析从服务器返回发送的数据报。

使用数据报连接来发送短消息。为获得更多信息，参看121页的“发送和接受SMS”。

使用UDP连接

为使用UDP连接，你必须有一个你自己的基础设施来连接无线网络，包括一个GPRS（General Packet Radio Service，通用分组无线业务）网络的APN（Access Point Name）。

注：数据报连接没有使用BlackBerry的基础设施，因此连接没有加密。模拟器的APN是net.rim.gprs.

javax.microedition.io.DatagramConnection接口，扩展了Connection类，它定义了发送和接受数据报的连接。Datagram接口定义了在数据报连接上发送和接受的数据包。

注：使用UDP连接需要你和服务商紧密联系。联系你的服务商确认UDP连接是否支持。

    如果你的服务商不支持多个PDP上下文，那么你可能没有建立一个UDP连接。一个PDP上下文为发送消息的BlackBerry.net.APN保留。尽管如此，你可以为UDP使用blackberry.net 当作APN。联系你的服务商以获得更多信息。

获得一个数据报连接

使用下面的格式调用Connector.open().指定udp为你的协议。将返回的对象转化为一个DatagramConnection。

(DatagramConnection)Connector.

open("udp://host:dest_port[;src_port]/apn");

注：可以在相同的端口上收发UDP数据报。

为了在UDP连接上发送数据，在连接字符串里指定目标端口。为了在UDP连接上接收数据，在连接字符串里指定源端口。为了接收指定主机的所有端口上的数据报，省略目标端口。

注：为了在一个非GPRS的网络里打开一个连接，不要指定APN。在源端口后包含斜线”/”.例如CDMA网络连接的地址应该是udp://121.0.0.0:6343/.

创建一个数据报

调用DatagramConnection.newDatagram().

将数据加入到数据报中

调用Datagram.setData().数据的格式由接收它的服务决定。

在UDP连接上发送数据

在数据报连接山调用send()。

注：如果应用程序试图在一个UDP连接上发送一个数据报,并且接收者没有监听指定的源端口,一个IOException会抛出.

接收UDP连接上的数据

调用数据报连接上的receive().

注：receive()方法会阻塞其他操作,直至它接收完一个数据包.如果你知道正在发送的数据格式,转化他们为合适的格式.

从数据报提取数据

在数据报连接上调用getData()方法。如果你知道正在接收的数据类型，将数据转化为合适的格式。

关闭UDP连接

和MIDP框架中所有连接一样，调用输入和输出流以及数据报上的close（）方法，

使用Mobitex网络

DatagramConnectionBase类提供了方法来处理Mobitex网络上的BlackBerry数据报连接以及传输操作。

打开一个Mobitex数据报连接

调用Connector.open(),然后将返回的对象转化为一个DatagramConnectionBase。DatagramConnectionBase类实现了DatagramConnection，并且提供了额外的方法，对注册一个数据报状态监听者来说，这些方法是必要的。

为提供一个参数给Connector.open(),连接字符串使用下面的格式：

mobitex:<type>:<MAN>

注：如果你打开一个服务器连接（一个监听者），MAN留为空白。

监听数据报状态事件

如果你想注册一个数据报状态事件监听者，使用一个DatagramBase，而不是Datagram来抓住（hold）数据。DatagramBase实现了Datagram接口，并且提供额外的方法，这些方法对注册数据报状态事件监听者是有用的。

注册一个数据报状态监听者

你的DatagramStatusListener接口的实现监听事件，例如一个数据报的接收。参看API参考的DatagramStatusListener以获得完整的数据报状态事件列表。

为了分配一个数据报ID，并将之显式指派给DatagramStatusListener，调用DatagramConnectionBase.allocateDatagramId().

以此种方式预先分配数据报ID，可以确保你的监听者代码知道与此ID相关联的数据报。

获得数据报信息

MobitexAddress类封装了Mobitex地址信息，例如MAN，消息的类型以及消息的状态。

MobitexPacketHeader类提供对无线头字段（radio header field）的底层访问。为了对所有地址操作使用MobitexPacketHeader并忽略其他的MobitexAddress字段，调用MobitexAddress.setPacketHeader().

获取无线和网络信息

MobitexInfo类提供对象存储普通的无线（radio）状态信息。Mobitex.MobitexCellInfo类提供对象存储Mobitex蜂窝信息。

代码实例

MobitexDemo.java代码实例描述了Mobitex无线称API的使用。

例：MobitexDemo.java

/*

* MobitexDemo.java

*

* Copyright (C) 2003-2005 Research In Motion Limited

*/

package com.rim.docs.samples.mobitexdemo;

import javax.microedition.io.*;

import net.rim.device.api.ui.*;

import net.rim.device.api.ui.component.*;

import net.rim.device.api.ui.container.*;

import net.rim.device.api.i18n.*;

import java.util.*;

import net.rim.device.api.io.*;

import net.rim.device.api.system.*;

import java.io.*;

import com.rim.docs.samples.baseapp.*;

/**

* A simple mobitex layer sample.

*/

public final class MobitexDemo extends BaseApp

     implements MobitexDemoResource {

    private MainScreen _mainScreen;

    private EditField _pin;

    private EditField _data;

    private RichTextField _messages;

    private SenderThread _sendThread;

    private ReceiverThread _receiverThread;

    // statics ——————————————————————

    private static ResourceBundle _resources =

       ResourceBundle.getBundle(MobitexDemoResource.BUNDLE_ID,

                               MobitexDemoResource.BUNDLE_NAME);

    static public void main(String[] args)

    {

       new MobitexDemo().enterEventDispatcher();

    }

    // menu items —————————————————————-

    // Cache the send menu item for reuse.

    private MenuItem _sendMenuItem = new MenuItem(_resources, MOBITEXDEMO_MENUITEM_SEND,

           100, 10) {

       public void run()

       {

           // Don’t execute on a blank address.

           String pin = _pin.getText();

           String data = _data.getText();

           if ( pin.length() > 0 )

           {

              send(pin, data);

           }

       }

    };

    // Cache the clear messages menu item for reuse.

    private MenuItem _clearMessages = new MenuItem(_resources,

           MOBITEXDEMO_MENUITEM_CLEARMESSAGES, 105, 10) {

       public void run() {

           _messages.setText("");

           }

    };

    public MobitexDemo()

    {

       _mainScreen = new MainScreen();

       _mainScreen.setTitle( new LabelField(_resources.getString(MOBITEXDEMO_TITLE),

              LabelField.ELLIPSIS | LabelField.USE_ALL_WIDTH));

       _pin = new EditField(_resources.getString(MOBITEXDEMO_LABEL_PIN), null,

              Integer.MAX_VALUE, EditField.FILTER_PIN_ADDRESS);

       _mainScreen.add(_pin);

       _data = new EditField(_resources.getString(MOBITEXDEMO_LABEL_DATA), null);

       _mainScreen.add(_data);

       _mainScreen.add(new SeparatorField());

       _messages = new RichTextField(_resources.getString(MOBITEXDEMO_CONTENT_DEFAULT));

       _mainScreen.add(_messages);

       _mainScreen.addKeyListener(this); //implemented by the super

       _mainScreen.addTrackwheelListener(this); //implemented by the super

       //start the helper threads

       _sendThread = new SenderThread();

       _sendThread.start();

       _receiverThread = new ReceiverThread();

       _receiverThread.start();

       //push the main screen - a method from the UiApplication class

       pushScreen(_mainScreen);

       }

    // methods ——————————————————————

    /*public boolean keyChar(char key, int status, int time)

     {

if ( UiApplication.getUiApplication().getActiveScreen().getLeafFieldWithFocus() ==

pin && key == Characters.ENTER )

{

_sendMenuItem.run();

return true; // I’ve absorbed this event, so return true.

}

else

{

return super.keyChar(key, status, time);

}

}*/

    protected void makeMenu(Menu menu, int instance)

    {

       menu.add(_sendMenuItem);

       menu.add(_clearMessages);

       menu.addSeparator();

       super.makeMenu(menu, instance);

    }

    private void send(String pin, String data)

    {

       _sendThread.send(pin, data);

    }

    private void message(String msg)

    {

       System.out.println(msg);

       _messages.setText(_messages.getText() + msg + "\n");

    }

    // inner classes ————————————————————-

    private class ReceiverThread extends Thread

    {

       private DatagramConnection _dc;

       // Shut down the thread.

       public void stop()

       {

           try {

              _dc.close();

              }

           catch(IOException e) {

              MobitexDemo.this.message(e.toString());

              }

       }

       public void run()

       {

           try {

              // Incoming data connection - leave the MAN blank.

              _dc = (DatagramConnection)Connector.open("mobitex:DATA:");

              for(;;)

              {

                  Datagram d = _dc.newDatagram(_dc.getMaximumLength());

                  _dc.receive(d);

                  DatagramBase db = (DatagramBase)d;

                  MobitexAddress ma = (MobitexAddress)db.getAddressBase();

                  MobitexPacketHeader mph = ma.getPacketHeader();

                  StringBuffer sb = new StringBuffer();

                  sb.append("Recieved packet");

                  sb.append("\nFROM:");

                  sb.append(mph.getSourceAddress());

                  sb.append("\nTO:");

                  sb.append(mph.getDestinationAddress());

                  sb.append("\nFLAGS:");

                  sb.append(Integer.toHexString(mph.getPacketFlags()));

                  sb.append("\nDATA:");

                  sb.append(new String(db.getData()));

                  MobitexDemo.this.message(sb.toString());

                  }

              }

           catch (IOException e) {

              MobitexDemo.this.message(e.toString());

              }

           }

    }

    /**

     * The ConnectionThread class manages the datagram connection

     */

    private class SenderThread extends Thread implements DatagramStatusListener {

       private static final int TIMEOUT = 500; //ms

       private Vector _sendQueue = new Vector(5);

       private volatile boolean _start = false;

       private volatile boolean _stop = false;

       // Queue something for sending

       public void send(String pin, String data)

       {

           synchronized(_sendQueue) {

              _sendQueue.addElement(new String[] { pin, data });

              _start = true;

           }

       }

       // Shut down the thread.

       public void stop() {

           _stop = true;

           }

       public void run()

       {

           for(;;) {

              String pin = null;

              String data = null;

              // Thread control.

              synchronized(_sendQueue) {

                  while( !_start && !_stop)

                  {

                     // Sleep for a bit so we don’t spin.

                     try {

                         _sendQueue.wait(TIMEOUT);

                         }

                     catch (InterruptedException e) {

                         System.err.println(e.toString());

                         }

                     }

                  if (_start) {

                     String[] a = (String[])_sendQueue.firstElement();

                     if ( a != null ) {

                         pin = a[0];

                         data = a[1];

                         }

                     _start = false;

                     }

                  else if ( _stop ) { // Exit condition

                     return;

                     }

                  }

              // Open the connection and extract the data.

              DatagramConnection dc = null;

              try {

                  String address = "DATA:" + pin;

                  dc = (DatagramConnection)Connector.open("mobitex:" + address);

                  //an error if this fails

                  DatagramConnectionBase dcb = (DatagramConnectionBase)dc;

                  Datagram d = dc.newDatagram(dc.getMaximumLength());

                  byte[] raw = data.getBytes();

                  d.setAddress(address);

                  d.setData(raw, 0, raw.length);

                  // An error if this fails.

                  DatagramBase db = (DatagramBase)d;

                  // Allocate a datagram ID - if you want to know about status.

                  // For this particular datagram, then we can allocate the id

                  // here and log it for later follow up              

                  dcb.allocateDatagramId(d);

                  // Set up a status listener.

                  db.setDatagramStatusListener(this);

                  dcb.send(d);

                  dc.close();

                  }

              catch (IOException e) {

                  MobitexDemo.this.message(e.toString());

                  }

              // We’re done one connection so reset the start state.

              _start = false;

              }

           }

       public void updateDatagramStatus(int dgId, int code, Object context) {

           String msg = "Datagram: " + Integer.toHexString(dgId) +

           "\nStatus: " + DatagramStatusListenerUtil.getStatusMessage(code);

           MobitexDemo.this.message(msg);

           }

       }

    protected void onExit() {

       _sendThread.stop();

       _receiverThread.stop();

       }

    }

发送和接收短消息

使用UDP在数据报包上发送和接收短消息（SMS）。包含了BlackBerry消息头信息的短消息数据报包，其大小是固定的160个字节。

注：短消息不是所有的网络都支持。和你的服务商确认是否相关的网络全部和部分支持SMS。大多数情况下，GPRS和支持CDMA的BlackBerry设备支持SMS。如果服务商提供SMS服务，系统管理员也可以使用IT策略来控制公司用户对SMS的使用。管理员可以将ENABLE_SMS项设置为TRUE或FALSE。缺省值是TRUE（SMS可用）。

发送SMS

打开一个数据报连接来发送SMS

调用Connector.open().使用下面格式提供一个连接字符串:

DatagramConnection _dc = Connector.open("sms://<peer_address>");

在这里，<peer_address>是接收者的电话号码－MSISDN（MobileStation ISDN Number）。

你也可以忽略peer_address，代替它的是调用Datagram.setAddress（）来设置消息的目的地地址。

创建一个SMS

调用DatagramConnection.newDatagram().

设置SMS内容

调用setData（）。

发送一个SMS消息

注：在一个与主应用程序线程独立的线程上打开网络连接，这样UI就不会停止。

如果你没有在连接字符串中指定peer_address，那么调用Datagram.setAddress（）设置SMS地址。为了发送SMS，调用DatagramConnection.send()。

代码实例

SendSms.java代码实例描述了如何在独立的线程上发送一条SMS消息。

在实例的工作空间中，SendSms.java实例需要一个服务器端的应用程序来与BlackBerry设备模拟器交互，来模拟发送和接收SMS消息。你不能从BlackBerry设备模拟器发送一个实际的SMS。

样例（SMSServer.java）的服务器端程序包含在BlackBerry JDE下。为了运行服务器端程序，运行run.bat，它在你的BlackBerry JDE实例的子目录下。例如:

\samples\com\rim\samples\server\smsdemo\.

例：SendSms.java

/**

* SendSms.java

* Copyright (C) 2002-2005 Research In Motion Limited. All rights reserved.

*/

package com.rim.samples.docs.smsdemo;

import net.rim.device.api.io.*;

import net.rim.device.api.system.*;

import javax.microedition.io.*;

import java.util.*;

import java.io.*;

public class SendSms extends Application {   

    private static final int MAX_PHONE_NUMBER_LENGTH = 32;

    // Members.

    private String addr = "15195551234";

    private String msg = "This is a test message.";

    private DatagramConnection _dc = null;

    private static String _openString = "sms://";

    public static void main(String[] args) {

       new SendSms().enterEventDispatcher();

       }

    public SendSms() {

       try {

           _dc = (DatagramConnection)Connector.open(_openString);

           byte[] data = msg.getBytes();

           Datagram d = _dc.newDatagram(_dc.getMaximumLength());

           d.setAddress("//" + addr);

           _dc.send(d);

           }

       catch ( IOException e) {

       }

       System.exit(0);

       }

}

接收SMS消息

创建一个独立的监听线程

在一个与主应用程序线程独立的线程上监听消息，以致UI不会停止。

打开数据报连接

调用Connector.open().使用下面的格式提供一个字符串连接：

_dc = (DatagramConnection)Connector.

open("sms://<peer_address><port>");

在这里：

• <peer_address>是接收者的电话号码－MSISDN（MobileStation ISDN Number）
• <port>是应用程序接收SMS消息的端口号。

获取数据报

创建一个Datagram对象存储数据报。为获取SMS消息数据报，调用数据报连接上的receive()。这个操作会阻塞直至数据接收完毕。

从数据报提取数据

为了从SMS消息提取地址，调用Datagram.getAddress().为了从SMS消息中提取数据，调用Datagram.getData().

代码实例

ReceiveSms.java描述了如何在一个独立的线程上接收一个SMS消息。

例：ReceiveSms.java

/**

* ReceiveSms.java

* Copyright (C) 2002-2005 Research In Motion Limited. All rights reserved.

*/

package com.rim.samples.docs.smsdemo;

import net.rim.device.api.io.*;

import net.rim.device.api.system.*;

import javax.microedition.io.*;

import java.util.*;

import java.io.*;

public class ReceiveSms extends Application {

    private ListeningThread _listener;

    // Additional code required for complete sample.

    public static void main(String[] args) {

       new ReceiveSms().enterEventDispatcher();

       }

    ReceiveSms() {

       _listener = new ListeningThread();

       _listener.start();

       }

    private static class ListeningThread extends Thread {

       private boolean _stop = false;

       private DatagramConnection _dc;

       public synchronized void stop() {

           _stop = true;

           try {_

              dc.close(); // Close the connection so the thread returns.

           }

           catch (IOException e) {

              System.err.println(e.toString());

              }

           }

       public void run() {

           try {

              _dc = (DatagramConnection)Connector.open("sms://");

              for(;;) {

                  if ( _stop ) {

                     return;

                     }

                  Datagram d = _dc.newDatagram(_dc.getMaximumLength());

                  _dc.receive(d);

                  String address = new String(d.getAddress());

                  String msg = new String(d.getData());

                  System.out.println("Message received:" + msg);

                  System.out.println("From:" + address);

                  System.exit(0);

                  }

              }

           catch (IOException e) {

              System.err.println(e.toString());

              }

           }

       }

    }

• Last Updated:2007年1月11日
• Last Updated:2006年4月28日Created

第6章 连接网络

HTTP和Socket连接

尽管你可以通过socket连接实现HTTP，但是最好使用HTTP连接，因为socket连接不支持BlackBerry MDS服务特性，例如push。也最好使用HTTP连接，因为比起那些使用HTTP连接的应用程序，使用socket连接的应用程序明显需要更多的带宽。

注：如果你使用socket连接，将你的应用程序设计为适应断断续续的无线网络连接。例如，如果你的程序发生错误时，它会重新打开连接。

使用HTTP连接

注：使用BlackBerry Internet Service Browser的java程序不会启动HTTP，HTTPS和TCP连接。

打开一个HTTP连接

为了打开一个HTTP连接，调用Connector.open(),指定http为协议。将返回的对象转化为一个HTTPConnection或者StreamConnection对象。HttpConnection是一个StreamConnection，它提供访问指定HTTP功能，包括HTTP头和其他HTTP资源。

设置HTTP请求方式

为设置HTTP请求方式（GET或POST），调用HttpConnection.setRequestMethod().

设置或获取头字段

为HTTP请求或HTTP响应消息设置或获取头字段，调用HttpConnection 上的getRequestProperty() 或setRequestProperty()。

发送和接受数据

为发送和接受数据，调用HTTPConnection的openInputStream()和openOutputStream()获得输入和输出流。

代码实例

HttpFetch.java 实例使用了一个HTTP 连接来获取数据。它遵循下列步骤：

1. 创建一个连接线程。
2. 定义一个方法获取数据。
3. 定义一个方法将数据显示给用户。
4. 定义一个方法退出应用程序。
5. 定义应用程序构造子。

注：HTTPFetch.java实例需要你在应用程序工程里创建资源文件，并且定义需要的资源键值。参看125页“本地化应用程序”获得更多信息。

例：HTTPFetch.java

/**

* HTTPFetch.java

* Copyright (C) 2001-2005 Research In Motion Limited. All rights reserved.

*/

package com.rim.samples.docs.httpfetch;

import net.rim.device.api.ui.*;

import net.rim.device.api.ui.component.*;

import net.rim.device.api.ui.container.*;

import net.rim.device.api.i18n.*;

import net.rim.device.api.system.*;

import javax.microedition.io.*;

import java.io.*;

import com.rim.samples.docs.baseapp.*;

import com.rim.samples.docs.resource.*;

public class HTTPFetch extends BaseApp implements HTTPFetchResource

{

    // Constants.

    private static final String SAMPLE_PAGE = "http://localhost/testpage/sample.txt”;

    private static final String[] HTTP_PROTOCOL =    {"http://", “http:\\”};

    private MainScreen _mainScreen;

    private RichTextField _content;

    /**

     * Send and receive data over the network on a

     * separate thread from the main thread of your application.

   */

    ConnectionThread _connectionThread = new ConnectionThread();

    //statics

    private static ResourceBundle _resources = ResourceBundle.getBundle(

       HTTPFetchResource.BUNDLE_ID, HTTPFetchResource.BUNDLE_NAME);

       public static void main(String[] args)

       {

           HTTPFetch theApp = new HTTPFetch();

           theApp.enterEventDispatcher();

       }

    /**

     * The ConnectionThread class manages the HTTP connection.

     * Fetch operations are not queued, but if a second fetch request

     * is made while a previous request is still active,

     * the second request stalls until the previous request completes.

     */

    private class ConnectionThread extends Thread

    {

       private static final int TIMEOUT = 500; //ms

       private String _theUrl;

       /* The volatile keyword indicates that because the data is shared,

        * the value of each variable must always be read and written from memory,

        * instead of cached by the VM. This technique is equivalent to wrapping

        * the shared data in a synchronized block, but produces less overhead.

        */

       private volatile boolean _start = false;

       private volatile boolean _stop = false;

       /**

        * Retrieve the URL. The synchronized keyword makes sure that only one

        * thread at a time can call this method on a ConnectionThread object.

        */

       public synchronized String getUrl()

       {

           return _theUrl;

       }

       /**

        * Fetch a page. This method is invoked on the connection thread by

        * fetchPage(), which is invoked in the application constructor when

        * the user selects the Fetch menu item.

        */

       public void fetch(String url)

       {

           _start = true;

           _theUrl = url;

       }

       /**

        * Close the thread. Invoked when the application exits.

        */

       public void stop()

       {

           _stop = true;

       }

       /**

        * Open an input stream and extract data. Invoked when the thread

        * is started.

        */

       public void run()

       {

           for(;;)

           {

              // Thread control.

              while( !_start && !_stop)

              {

                  // No connections are open for fetch requests,

                  // but the thread has not been stopped.

                  try

                  {

                     sleep(TIMEOUT);

                  }

                  catch (InterruptedException e)

                  {

                     System.err.println(e.toString());

                  }

              }

              // Exit condition.

              if ( _stop )

               {

                  return;

              }

              /* Ensure that fetch requests are not missed

               * while received data is processed.

               */

              synchronized(this)

              {

                  // Open the connection and extract the data.

                  StreamConnection s = null;

                  try

                  {

                     s = (StreamConnection)Connector.open(getUrl());

                     InputStream input = s.openInputStream();

                     // Extract data in 256 byte chunks.

                     byte[] data = new byte[256];

                     int len = 0;

                     StringBuffer raw = new StringBuffer();

                     while ( -1 != (len = input.read(data)) )

                     {

                         raw.append(new String(data, 0, len));

                     }

                     String text = raw.toString();

                     updateContent(text);

                     input.close();

                     s.close();

                  }

                  catch (IOException e)

                  {

                     System.err.println(e.toString());

                     // Display the text on the screen.

                     updateContent(e.toString());

                  }

                  // Reset the start state.

                  _start = false;

              }

           }

       }

    }

    // Constructor.

    public HTTPFetch()

    {

       _mainScreen = new MainScreen();

       _mainScreen.setTitle(new LabelField(

           _resources.getString(APPLICATION_TITLE), LabelField.ELLIPSIS

           | LabelField.USE_ALL_WIDTH));

       _mainScreen.add(new SeparatorField());

       _content = new RichTextField(

           _resources.getString(HTTPDEMO_CONTENT_DEFAULT));

       _mainScreen.add(_content);

       _mainScreen.addKeyListener(this);

       _mainScreen.addTrackwheelListener(this);

       // Start the helper thread.

       _connectionThread.start();

       pushScreen(_mainScreen);

       fetchPage(SAMPLE_PAGE);

    }

    // Retrieve web content.

    private void fetchPage(String url)

    {

       // Perform basic validation (set characters to lowercase and add http:// or https://).

       String lcase = url.toLowerCase();

       boolean validHeader = false;

       int i = 0;

       for (i = HTTP_PROTOCOL.length - 1; i >= 0; –i)

       {

           if ( -1 != lcase.indexOf(HTTP_PROTOCOL[i]) )

           {

              validHeader = true;

              break;

           }

       }

       if ( !validHeader )

       {

           // Prepend the protocol specifier if it is missing.

           url = HTTP_PROTOCOL[0] + url;

       }

       // Create a new thread for connection operations.

       _connectionThread.fetch(url);

    }

    // Display the content.

    private void updateContent(final String text)

    {

       /* This technique creates several short-lived objects but avoids

        * the threading issues involved in creating a static Runnable and

        * setting the text.

        */

       UiApplication.getUiApplication().invokeLater(new Runnable()

       {

           public void run()

           {

              _content.setText(text);

           }

       });

    }

    // Close the connection thread when the user closes the application.

    protected void onExit()

    {

       _connectionThread.stop();

    }

}

使用HTTPS连接

注：BlackBerry Internet Service Browser不允许Java应用程序启动HTTP，HTTPS和TCP连接。

打开一个HTTPS连接

为打开一个HTTPS连接，调用Connector.open()，指定https作为协议。将返回的对象转化为一个HttpsConnection；

指定代理或终端到终端（end_to_end）模型

缺省的，连接在代理模型中使用HTTPS。用户也可以设置一个BlackBerry设备选项来使用缺省的end_to_end模型。为获得更多信息，参看189页的“HTTPS支持“。

为了在end_to_end模型里打开一个HTTPS连接，将下列参数中的一个增加到传递给Connector.open()的连接字符串中：

注：BlackBerry设备缺省没有安装end_to_end模块。尽管这样，BlackBerry 桌面版软件3.6.0及后续版本中包含了它。当应用程序加载到BlackBerry设备时，为了加载模块，为你的应用程序在.alx文件中加入下面的标记：

为获得更多信息，参看183页的”.alx文件”。

使用socket连接

注：BlackBerry Internet Service Browser不允许Java应用程序启动HTTP，HTTPS和TCP连接。

指定TCP的设置

应用程序可以在下面的一种模式下建立一个TCP socket连接或一个在TCP上的HTTP连接。

注：使用直接TCP模式需要你和服务提供商一起紧密工作。联系你的服务提供商确保支持直接TCP socket连接。

为了通过编程指定TCP设置，增加可选的deviceside参数到传递给Connector.open()的连接字符串。

在GSM网络里，为指定BlackBerry设备商的TCP设置，用户点击BlackBerry设备选项的TCP。

注：如果IT策略设置允许TCP连接，TCP才在BlackBerry设备选项里显示。

如果TCP设置没有指定，下将使用下面缺省的。

参看API参考的Connector获得更多信息。

打开一个socket连接

为打开一个socket连接，调用Connector.open(),指定socket为其协议。

注：应用程序必须显式的输入他们的本地机器IP，因为localhost不被支持。

在socket连接上发送和接收数据

使用openInputStream() 和openOutputStream()获得输入和输出流。

关闭连接

调用输入和输出流，以及socket连接上的close()方法。

注：每个close()方法抛出一个IOException。应用程序必须实现这个异常的处理。

使用端口连接

注：当你的应用程序首先访问net.rim.device.api.system.SerialPort类或net.rim.device.api.system.USBPort类时，检查NoClassDefFoundError。如果系统管理员使用应用程序管理限制访问序列端口和USB接口，这个错误就会抛出。参看16页的“应用程序管理”获得更多信息。

当它们使用一个序列端口或USB接口连上一台计算机式，应用程序可以使用一个序列端口或USB接口和桌面的应用程序进行通信。连接类型也可以使用来和一个插到序列端口或USB接口的外围设备通信。

注：如果你正在使用端口连接和桌面应用程序通信，你不必让所有其他正在使用序列端口或USB接口的应用程序运行。

打开一个USB接口或序列端口连接

调用Connector.open(),指定comm作为协议，COM1或USB作为端口。

在端口连接上发送数据

调用openDataOnputStream() 和openOutputStream()获得输出流。

使用输出流上的写方法来写数据。

在端口连接上接收数据

调用openDataInputStream() 和openIutputStream()获得输入流。

使用输入流上的读方法来写数据。

注：你不能从在主事件线程上的输入流读取，因为这个操作会阻塞直至数据接收完成。创建一个独立的线程，在此线程上接收数据。

关闭端口连接

调用输入和输出流，以及端口连接上的close()方法。

注：每个close()方法可能抛出一个IOException异常。应用程序必须实现异常的处理。

使用蓝牙序列端口连接

蓝牙API（net.rim.device.api.bluetooth）允许应用程序访问蓝牙序列端口配置（Profile）以及允许启动一个服务器或者客户端蓝牙序列端口连接到一台计算机或其他蓝牙无线技术支持的设备。

注：当你的应用程序首先访问蓝牙API时，会检查NoClassDefFoundError。如果系统管理员使用应用程序管理限制访问序列端口和USB接口，这个错误就会抛出。参看16页的“应用程序管理”获得更多信息。

 BlackBerry模拟器不支持蓝牙。

打开一个蓝牙序列端口连接

为了打开一个蓝牙序列端口连接，调用Connector.open(),它提供由BluetoothSerialPort.getSerialPortInfo()返回的序列端口信息作为参数。

由这个方法返回的连接字符串指定了作为协议的btspp:// 以及下面条目之一：

• 如果你正在打开一个连接作为客户端，由getSerialPortInfo().toString()返回的连接字符串包含了设备号（device ID）以及Server设备正在监听的端口。
• 如果你正在打开一个连接作为服务器，由getSerialPortInfo().toString()返回的连接字符串包含了你的BlackBerry设备正在监听的端口。

在蓝牙序列端口连接上发送数据

调用openDataOutputStream()或openOutputStream()获得一个输出流。

注：直到连接建立，这个调用会阻塞。

在输出流上使用写方法来写数据

在蓝牙序列端口连接上接收数据

调用openDataInputStream()或openInputStream()获得一个输入流。

在输入流上使用读方法来读数据

注：你不能在主事件线程上读取输入流数据，因为这个操作会阻塞直到数据接收完毕。创建一个独立的线程来接收数据。                                   

关闭一个端口连接

在输入和输出流以及蓝牙序列端口连接上调用close()方法。

代码实例

BluetoothSerialPortDemo.java实例使一个简单蓝牙序列端口应用程序的客户端。这个应用程序监听在序列端口上的数据，并且当数据到达时提交数据。

例：BluetoothSerialPortDemo.java

/**

* BluetoothSerialPortDemo.java

* Copyright (C) 2004-2005 Research In Motion Limited.

*/

/* The client side of a simple serial port demonstration application.

* This application listens for text on the serial port and

* renders the data when it arrives.

*/

package com.rim.samples.docs.bluetoothserialportdemo;

import java.io.*;

import javax.microedition.io.*;

import net.rim.device.api.bluetooth.*;

import net.rim.device.api.ui.*;

import net.rim.device.api.ui.component.*;

import net.rim.device.api.ui.container.*;

import net.rim.device.api.i18n.*;

import net.rim.device.api.system.*;

import net.rim.device.api.util.*;

import com.rim.samples.docs.baseapp.*;

import com.rim.samples.docs.resource.*;

public class BluetoothSerialPortDemo extends BaseApp implements BluetoothSerialPortDemoResResource {

    //statics ——————————————————————

    private static ResourceBundle _resources;

    private static final int INSERT = 1;

    private static final int REMOVE = 2;

    private static final int CHANGE = 3;

    private static final int JUST_OPEN = 4;

    private static final int CONTENTS = 5;

    private static final int NO_CONTENTS = 6;

    static {

       _resources = ResourceBundle.getBundle(BluetoothSerialPortDemoResResource.BUNDLE_ID,

              BluetoothSerialPortDemoResResource.BUNDLE_NAME);

        }

    private EditField _infoField;

    private StreamConnection _bluetoothConnection;

    private DataInputStream _din;

    rivate DataOutputStream _dout;

    public static void main(String[] args)

    {

       BluetoothSerialPortDemo theApp = new BluetoothSerialPortDemo();

       theApp.enterEventDispatcher();

    }

    //constructor ————————————————————–

    public BluetoothSerialPortDemo()

    {

       MainScreen mainScreen = new MainScreen();

       mainScreen.setTitle(new LabelField(_resources.getString(TITLE),

              LabelField.USE_ALL_WIDTH));

       _infoField = new EditField(Field.READONLY);

       mainScreen.add(_infoField);

       mainScreen.addKeyListener(this);

       mainScreen.addTrackwheelListener(this);

       pushScreen(mainScreen);

       invokeLater(new Runnable()

       {

           public void run() {

              openPort();

              }

       });

    }

    protected void onExit() {

       closePort();

    }

    // Close the serial port.

    private void closePort() {

       if (_bluetoothConnection != null)

       {

           try {

              _bluetoothConnection.close();

              }

           catch(IOException ioe) {

              }

           if (_din != null)

           {

              try {

                  _din.close();

                  }

              catch(IOException ioe) {

                 }

            }

           if (_dout != null) {

               try {

                  _dout.close();

                  }

              catch(IOException ioe)

              {

              }

           }

           _bluetoothConnection = null;

           _din = null;

           _dout = null;

           }

    }

    // Open the serial port.

    private void openPort() {

       if (_bluetoothConnection != null) {

           closePort();

           }

       new InputThread().start();

       }

    private class InputThread extends Thread {

       public void run() {

           try {

              BluetoothSerialPortInfo[] info =

                  BluetoothSerialPort.getSerialPortInfo();

              if( info == null || info.length == 0 ) {

                  invokeAndWait( new Runnable() {

                     public void run() {

                         Dialog.alert( "No bluetooth serial ports available for connection.");

                         onExit();

                         System.exit(1);

                         }

                     });

              _bluetoothConnection = (StreamConnection)Connector.open( info[0].toString(),

                     Connector.READ_WRITE);

              _din = _bluetoothConnection.openDataInputStream();

              _dout = _bluetoothConnection.openDataOutputStream();

              }

           catch(IOException e) {

              invokeAndWait( new Runnable() {

              public void run() {

Dialog.alert(“Unable to open serial port”);

onExit();

System.exit(1);

}

});

} catch( UnsupportedOperationException e ) {

invokeAndWait( new Runnable() {

public void run() {

Dialog.alert(“This handheld or simulator does not support bluetooth.”);

onExit();

System.exit(1);

}

});

}

try {

int type, offset, count;

String value;

_dout.writeInt(JUST_OPEN);

_dout.flush();

for (;;) {

type = _din.readInt();

if (type == INSERT) {

offset = _din.readInt();

value = _din.readUTF();

insert(value, offset);

}

 else if (type == REMOVE) {

offset = _din.readInt();

count = _din.readInt();

remove(offset, count);

}

else if (type == JUST_OPEN) {

// Send contents to desktop.

value = _infoField.getText();

if (value == null || value.equals(““)) {

_dout.writeInt(NO_CONTENTS);

_dout.flush();

}

else {

_dout.writeInt(CONTENTS);

_dout.writeUTF(_infoField.getText());

_dout.flush();

}

}

else if (type == CONTENTS) {

String contents = _din.readUTF();

synchronized(Application.getEventLock()) {

_infoField.setText(contents);

}

}

else if (type == NO_CONTENTS) {

}

else {

throw new RuntimeException();

}

}

}

catch(IOException ioe) {

invokeLater(new Runnable() {

public void run() {

Dialog.alert(“Problems reading from or writing to serial port.”);

onExit();

System.exit(1);

}