简介

通过这篇文章我们想为大家带来一些Symbian操作系统的有关sockets API的基本介绍。 本文的读者应该是希望在他们的应用程序中增添socket通信功能的Symbian操作系统的开发者，本文不仅提供了理论介绍，同样给出了可供实践参考的代码范例。

本文包含的内容有:

• 概括介绍了有关socket通信的有关组件。
• 概括介绍了socket服务架构以及使用两个主要API类RSocketServ和RSocket的使用。
• 讨论了创建两个终端之间进行通信的过程。
• 讨论了socket之间通信的不同模式：基于一串数据流的模式以及基于离散消息的模式。
• 一个如何使用活动对象来进行socket连接的实践范例。

有关Socket的服务构架

本文的一个内容是介绍给大家如何将基于Socket服务的通信功能加入到应用程序中来。尽管如此，计算机通信系统乃是一个十分复杂的系统，本文介绍的基于socket服务的通信仍然是在一个相对比较高级的层次，没有深入底层探讨的话题和技术。要想让socket服务来发挥作用，许多底层支持软件将是必须的。

下图说明了socket服务组件在Symbian系统的通信子系统中的哪一层位置，扮演如何一个角色。

Symbian OS通信系统组件

首先我们来考虑传输层协议。上图的Internet互联网协议和红外协议，从Symbian 6.0之后支持的蓝牙®无线通讯技术以及都在这一层中。

当我们谈到Internet协议时，我们其实包括了一个隐式的依赖动作，那就是向ISP（互联网服务提供商）进行拨号连接。因此，如图所示我们可以看到Symbian系统提供了拨号网络接入组件。而在本图中，最重要的的系统组件是电话通信服务组件。

最终，我们需要设计到一个硬件设备，有了硬件我们才可以在选定的网络环境中接收和发送数据。上图的核心部分就是使用Internet协议的拨号接入网络，并且显示了串行通信组件在整个通信系统扮演了如何的角色。串行通信服务组件通过特定的硬件设备驱动，完成了硬件设备与它周围环境的通信。

什么是socket?

那么什么是socket呢? 用一句引自伯克利（Berkeley）UNIX关于socket实现的经典定义来回答就是“socket就是通信终端”。

那究竟是什么意思呢?

一个socket代表了一条通信‘通道’逻辑上的终端。而实际上讲，socket是物理网络地址和逻辑端口号的一个集合，而这个集合可以向另外一个位置的与他具有相同定义的socket进行数据传输。

因为socket是由机器地址和端口号来区分/识别的，那么在一个特定的计算机网络上，每一个socket都是以此方式被唯一识别的。这就使得应用程序可以唯一地去定位网络上的另外一个位置的socket。

注意：对于同一台机器上的两个socket，他们是完全具备彼此间进行通信的可能的；在这种情况下，两个socket具有相同的主机地址，但是他们拥有不同的端口号。

主机地址和端口号的组合，对于不同协议是不同的。在socket的经典应用中，网络通信使用的是IP（Internet Protocol）协议，但是实际上socket是支持很多其它协议的，对于这方面的信息稍后会提到。

正如我们将会看到的，不管我们选择怎样的通信协议（传输层），我们都可以使用同一种已成熟的socket API来实现通信。

协议模块

如上文所述，socket的经典应用是在TCP/IP协议的计算机网络上，使两个逻辑端点之间展开通信活动。最著名的应用TCP/IP的计算机网络，当然就是Internet了。

绝大多数socket系统的实现都限定在了TCP/IP网络的通信上。

但是，Symbian系统的socket服务组件，就实现了更多的内容；不仅如此，它还为其他组件提供了支持模块插件协议的基础构架。这就使得Symbian公司和它的开发伙伴们大大延长了socket服务组件以及支持socket的应用程序的应用时间。

由于新协议和传输层的引入，支持了新的传输‘语言’或协议的协议组件，从而使得socket服务组件可以随之适应新的应用环境。

随着Symbian系统第五版的socket服务组件支持了TCP/IP和红外协议的稽核。在Symbian 6.0版的时候，就增加了蓝牙®无线技术和短信息服务插件。

协议模块其实就是标准的Symbian系统动态链接库（DLL）。他们都有共同的UID2--KUidProtocolModule(0x1000004A)来表示他们的类型，并且拥有特殊的扩展名*.PRT。

一个关于经典系统的方面，就是socket服务对PLP（Psion Link Protocol）协议也是支持的。PLP被用来进行Symbian系统的手机和运行Microsoft Windows的台式或笔记本计算机之间进行通信。PLP的一个应用就是Symbian Connnect - 目前的被用于名为‘PsiWin’的Psion计算机。

socket服务组件可以以两种方式加载协议模块：

• 最通常的做法就是，协议模块会在第一个使用该协议的socket被打开的时候进行加载。
• 另外一种做法是，应用程序可以显式地加载协议模块。这种做法的一个好处就在于，当协议加载需要一个比较长的时间的时候，应用程序或用户可以得到相应的提示。使用这种方法调用的API在本文的后面将会进行讨论。

要说明的几点：一个协议模块可以包含多种协议实现。比如，在TCPIP.PRT模块中，就包含了UDP、TCP、ICMP、IP以及DNS协议的实现。单个协议的实现可以通过位于\system\data\.的.esk文件进行映射。而每个协议模块都有一个.esk文件来指定该模块所包含的协议，以及每个协议在插件模块中所处的索引位置。

传输的独立性

上文已经提到，socket服务组件的插件架构特性可以使得新的协议模块在任何时间被安装到一部Symbian系统的手机当中。

这个架构可以使得socket服务组件来实现独立传输层的概念。借助于提供一个通用的核心socket API接口，这种架构就可以处理所有一般性数据传输系统的需求，并且通过添加特定协议的协议模块，socket服务组件就可以被广大应用程序开发者来给自己的产品增添通信功能，从而省下了大量的开发通信子系统的时间。

随着时间的发展，新的协议逐步登上历史舞台，协议模块都将会为了适应socket接口而被重写。而应用程序开发者，他们只需要增添协议新近引入的属性或者动作，来支持新的协议即可，Socket服务组件便会使用新的协议，借助操作系统底层的通信组件，来完成通信机制，而并不会影响到上层应用程序开发者的接口和开发。

总而言之，socket服务组件可以让应用程序开发者在仅仅维护一套核心API接口的情况下，可以借助操作系统的通信子系统来使用多个协议，从而减少了自己的开发工作量以及开发时间。

“客户端-服务器”接口

Symbian系统的一个特点就是它具有一个体积很小的微内核（micro-kernel），因此我们只能把必须和硬件设备交互以及进行主机控制的核心服务放在内核端运行。而另外许许多多的系统服务只能以用户模式的服务器线程的形式运行，通常被称为‘系统服务器’。

socket服务组件就是这些‘系统服务器’中的一个，第三方应用程序就借助公开的客户端API，通过该组件完成通信功能。其中最重要的四个类为：

• RSocketServer: 这个类是用来建立和socket服务组件之间的连接以及获取必要的资源的。在客户端-服务器架构的定义中，该类表示了应用程序与socket服务组件之间建立连接的会话。所有的其他客户端接口类，在使用中都需要一个被打开的本类的实例来进行操作。

• RSocket: 这个类表示了一个socket连接。一个标准的应用程序可能会在不同时间的时候，拥有若干个RSocket的实例在同时进行操作。

• RHostResolver: 这个类用来提供主机名称解析服务的接口。

• RNetDatabase: 这个类用来提供网络数据库访问的接口。

RSocket, RHostResolver & RNetDatabase 均表示了一个给定的应用程序与socket服务组件之间进行的会话下的子会话，而应用程序与socket服务组件之间的会话就是一个RSocketServer的实例。

sockets服务器的主要类

socket服务组件提供了两个主类，供他的客户端访问内部的API。

• RSocketServ: 在每个应用程序线程中，只要需要连接socket请求，他就必须使用一个本类的实例，来为其他连接（会话）提供socket服务。

• RSocket: 每一个需要使用socket的应用程序线程，同样也需要一个或多个RSocket对象，这些对象就是子会话了。

下面的两个部分将会介绍会话和子会话类（RSocketServ 和 RSocket）的详细内容。

使用RSocketServ类

RSocketServ类扮演了一个十分重要的角色，因为它是客户端应用程序与socket服务组建之间的连接会话。

但是，客户端应用程序并不直接使用这个类来进行数据的发送和接收，或者创建一个远程通信端点；要完成这些任务的话，使用的是RSocket类，这个类将会在稍后进行介绍。

RSocketServ可以让客户端应用程序来向socket服务组件发起一些查询，查询的内容包括服务器支持的协议个数以及支持哪些协议，每个支持协议的具体信息等等。

希望使用socket的客户端应用程序，都将需要自己创建一个RSocketServ类的实例对象，用这个对象来表示该客户端应用程序和socket服务之间的会话。每一个独立的socket连接，都是一个独立的RSocket类的实例对象。可以说，在一个客户端应用程序中，该程序的RSocketServ类对象就是所有的RSocket类对象的容器。

RSocketServ类的两个常用函数就是Connect()和StandardProtocol()。

建立一个连接到sockets服务的会话

使用Connect()方法，应用程序就可以建立与socket服务之间的一个会话。它仅仅使用一个参数--该会话所提供的消息通道的个数。

 TInt Connect (TUint aMessageSlots); 

消息数参数被用来限定应用程序向socket服务所同时并发的异步操作的请求通道数。每一个同步请求都将占用一个消息通道，并且请求准备中的异步操作也将占用一个消息通道。

一个普通socket进行的读写通信操作，都是异步进行的，也就是说这样的操作要占用两个消息通道。如果socket也可以进行同步操作的话，那么我们其实并不需要指定过多的消息通道，因为同步操作的消息通道是由socket客户端-服务器框架来完成的。对于你的应用程序在同一个时间内会使用到多少个消息通道，这完全是由你来断定的，而在大多数情况下，我们要尽可能的减少同时请求的消息通道数。

如果我们不指定任何特定的值，那么系统会使用一个默认值作为消息通道个数的参数：KESockDefaultMessageSlots (0x08)。

预载入协议模块

socket服务组件载入协议协议模块的动作是动态进行的，当针对某一个协议的第一个socket被创建的时候，该协议模块在此时才会被载入。尽管如此，载入协议仍然是一件比较费时的操作，RSocketServ提供了一个StartProtocol()函数，来进行协议模块的预载入操作，调用该函数可以在socket连接请求的时候节省载入协议模块的时间。

如果你的应用程序需要在程序启动之初就载入协议模块，而并非需要连接的时候才进行载入，那么可以使用下面的函数范例来调用StartProtocol()方法：

    void StartProtocol (TUint aFamily, TUint aSockType,
        TUint aProtocol, TRequestStatus& aStatus);
        

StartProtocol()函数的参数有：协议族(例如,KAfInet)，使用该协议的socket类型(例如,KSockStream)，协议族中的协议标示(例如,KProtocolInetTcp)，最后一个参数是异步调用的完成状态参数。这些参数的意义将会在下面做以简短介绍。

请注意，尽管StartProtocol()函数是一个异步服务，但是它却是一个在操作过程中不能被取消的操作。

使用RSocket类

RSocket代表了应用程序的一个socket连接，在一个应用程序中，每一个socket连接都是一个单独的RSocket的实例。事实上，客户端应用程序的代码中使用更多的是RSocket类而并不是RSocketServ类。

RSocket是一个提供了许许多多服务的体积庞大的类，这些服务包括：

• 连接到服务，无论作为客户端还是服务端
• 设置或者查询自己的地址，或者查询远程地址
• 从socket读取数据
• 向socket写入数据
• 其他更多...

在打开任何socket之前，我们必须有一个激活了的RSocketServ会话。并且，在上述提到的任何服务进行操作之前，我们要确保socket是打开的。作为打开一个socket的一部分，RSocket这个子回话对象（见上文说明）需要同一个socket服务器进行连接，这个服务器就是一个RScoketServ类的实例。

下面的章节介绍了RSocket的各种函数，有了这些函数的介绍和帮助我们就可以写出基于socket通信的应用程序来。

主机解析服务

什么是主机解析?

在一个由计算机组成的网络里，独立的主机使用不同的地址格式来判断各自是谁，是什么。

例如，你的电子邮件有可能保存在一台主机当中，这台主机可能有一个可读的地址，比如pop3.freeserve.net。这个地址尽管对人来说是可读的、是一个具有一定意义的地址，但是对于网络上的计算机来说，并没有任何直接的用处。

当你的邮件客户端程序尝试下载你可能会收到的电子邮件的时候，你的电脑就会使用你的电子邮件服务器的地址（先前举例的pop3.freeserve.net）去进行查询，将他们相对应的数字网络地址查询出来。当获得了机器可读的数字网络地址，应用程序才可能建立起连接。在TCP/IP协议族中，地址解析转换是由域名解析服务（Domain Name Service, DNS）进行的。

地址解析服务的用处有两个。首先，它可以让计算机网络（在本例中指的是Internet）的用户可以使用一个直接的、有意义的、人们可以理解并且可以记住的的地址来指向某一个网络资源。也许你曾经见过这样的网络地址212.134.93.203、204.71.202.160，但是一般情况下也许你并不会使用这样的数字地址去访问网络，一般情况下你更多使用的是例如www.symbian.com或者www.yahoo.com这样的地址。

其次，这种将网络物理地址和用户记忆的网络资源地址进行分割的服务，达到了网络硬件层进行升级或者替换的情况下并不会影响到用户访问的目的。这种机制也从另外一种情况下帮助了大的网络服务提供商，比如微软公司的Hotmail服务，使这些运营商可以在世界各地部署本地服务器，从而让每一个用户获得更快的访问速度，无论用户是在西雅图或者别的任何地方。

使用RHostResolver类

作为客户端API的一部分，socket服务组件提供了RHostResolver类，用这个类我们可以获得一个通用的主机地址解析服务，这项服务的内部会自己处理相应不同协议的主机地址解析的细节问题。如果我们针对TCP/IP协议族而言，那么RHostResolver类扮演的就是客户端与域名解析服务（DNS）之间进行通信的服务角色。

每一个不同的协议，都提供了自己的主机解析服务，这些服务是作为协议模块的一个标准部分实现的。这样的设计就使得客户端可以仅仅访问RHostResolver类，而并不需要关心socket使用的是哪一种协议。

RHostResolver接口提供了如下几种功能供客户端应用程序访问，他们是:

• 将一个数字网络地址转换为人所能识别的包含一定意义的文本表现形式
• 将人读地址转换为相对应的机读数字地址
• 读取或者设置本地设备的主机名的方法/函数

就像是RSocket一样，RHostResolver类继承自RSubSessionBase。因此，要想使用RHostResolver类，客户端应用程序就必须先进行对socket服务组件的服务器的连接，这个服务组件的服务器就是一个RSocketServ类的实例。

RHostResolver类提供了许多主机地址解析服务的函数/方法，每一个函数都提供了两个版本的多态函数--同步和异步操作。

请注意，因为这是一个通用的主机地址解析接口，但是并不是所有的协议都提供了主机地址解析服务，所以有些协议可能并没有提供任何主机地址解析服务。

如果客户端应用程序尝试使用RHostResolver中的函数去对一个不支持主机地址解析服务的协议请求主机地址解析服务，那么将会得到错误代码KErrNotSupported。

在进行任何主机地址解析服务之前，我们要打开一个RHostResolver类的实例。正如前面所提到过的，因为主机解析服务类是一个子会话类，所以在调用RHostResolver::Open()函数之前，该子会话类必须关联一个socket服务组件的服务器会话对象实例。

    TInt Open(RSocketServ& aSocketServer, TUint anAddrFamily,
        TUint aProtocol);
        

下一步，我们将会根据上面所示的函数原形，制定我们希望用哪个地址类型来解析的主机地址，地址类型应该是和传递给RSocket::Open()函数的参数一致的。

最后，我们还需要指定一个协议来进行主机地址解析服务。如果之前选择的地址类型是协议无关类型的，那么我们可以在这里指定KUndefinedProtocol。

其他的RHostResolver类提供的函数如下所示:

    TInt GetByName(const TDesC& aName, TNameEntry& aResult);
        TInt GetByAddress(const TSockAddr& anAddr, TNameEntry& aResult);
        TInt GetHostName(TDes& aName);
        TInt SetHostName(const TDesC& aName); // sync only
        TInt Next(TNameEntry& aResult);
        

这些函数中的大多数都是可以见名知意的；不过Next()函数例外，我们来进行一些解释：对于有些协议来说，GetByName()和GetByAddress()函数可能会一次找到不止一个结果，比如地址假名被允许的时候。如果这样的话，我们就需要调用Next()函数来返回下一个地址结果。

域名服务(DNS)

域名解析服务（Domain Name Service,DNS）是TCP/IP协议所提供的主机解析服务。

一个标准的DNS查询一般由以下三个步骤组成:

• 一个在某一个网络硬件设备（例如一块以太网卡）设备上运行的客户端应用程序，将自己的查询主机请求发送给网络上的另外一台主机--DNS服务器。
• DNS服务器将查询请求进行查询，查询是在庞大的数字地址与主机名称对应列表中进行的，查询到的结果将会被转换成不同的地址格式。
• DNS服务器将地址发送回客户端。

请注意，DNS服务可以将文本格式的地址（例如www.symbian.com）解析为数值格式地址（例如212.134.93.203），或者将数值地址（204.71.202.160）解析为文本格式的地址——www.yahoo.com。

互联网服务提供商一般都提供了很多DNS服务器（一般都不只一台）来供他们的客户使用。如果没有这些服务器，那么使用互联网对于普通用户来说将是一场灾难。如果没有DNS的话我们将不得不记住我们感兴趣的web站点的32位数字地址，或者使用十分十分冗长难记的地址去给其他人发电子邮件。

这里我们需要注意的重要一点是，实际上地址转换这项工作并不是客户端设备进行的，而是待转换地址被发送到了另外一台主机，由另外一台主机进行的解析。所以我们在建立一个使用TPC/IP协议建立连接的时候，就必须提供一个DNS服务器地址，否则一切连接将几乎无法进行。

在socket代码中使用活动对象（active objects）

计算机网络通信，在一般情况下都是使用异步操作的。下面我们先放下谈论已久的socket通信系统，来看看一个打电话过程是如何进行的，这样会有助于我们理解下面要讨论的问题。

当一个朋友给你打电话，你的电话机会收到电话打入的电信号，它在收到这个信号后就开始振铃，然后你听到了铃声之后就拿起听筒，开始进行通话，直到挂断电话此次通话结束。

当等待电话呼叫的时候，我们可以进行其他任何事情，并不会对我们的生活造成影响。与此的，假如你的朋友给你发送了一个是十分困难的问题让你帮助解决，也许这是一个相当大的难题，你要花一些时间来考虑或者解决，当这个时候，你的朋友可以利用你考虑或者解决的时间，进行他自己的其他活动。

上面的电话通信例子，就是一个很好的一部通信系统的例子。

当我们使用socket来在两台计算机之间传输数据的时候，我们看到的是一个类似上面打电话例子的异步模型。

在一个使用socket进行网络通信的应用程序中，上述异步通信的事件包括：

• 连接, 断开连接以及确认请求连接的要求
• 接受数据(因为我们并不知道有多少数据要发送过来，所以这个过程是异步的)
• 发出数据(因为对于应用程序层来说，我们并不知道底层的硬件需要多长时间才能够将数据发出，所以这个过程也是异步的)
• 其他，比如载入协议模块之类的，看似并不是十分明显的异步操作

因为我们需要在应用程序中处理这些异步事件，所以我们需要用到Symbian OS的活动对象（Active objects, AOs）来解决这些问题。

活动对象的特点有:

• 使得应用程序开发者可以很容易的控制对象的生存周期
• 在一个单线程程序中完成并非严格意义上的多任务操作
• 为Symbian系统提供了效率较高的单线程多任务解决方案，而并不是真正地使用多线程。

在Symbian系统中，所有的线程都是通过一个或者多个活动对象，使用一个激活的进度管理器来进行高效率的外部事件处理。

一个活动对象，在一个时间内只能处理一个事件源。在实际情况中，活动对象通常也都是被设计为处理一类特定事件的。

在稍后的代码示例中，这些代码因为有不同的需求所以使用了不止一个活动对象，无论是客户端还是服务器程序，都使用了不止三个活动对象。其中一个用来处理连接机制，一个用来接收数据，另外一个用来发送数据。

下面我们就来看看如合利用活动对象来处理客户端和服务器之间进行socket流式连接的范例。

代码示例: 连接sockets

下面一部分就是借助代码的演示来向大家说明如何利用活动对象进行socket连接。这写代码段是从一个进行监听接入连接的‘服务器’和发送连接请求到服务器的‘客户端’程序中提取出来的。

服务‘监听’类的定义

下面的代码是从一个完整的进行‘监听’（listening）的服务器类定义中取出的一部分。

class CModel : public CActive {
        public:
        void StartEngineL(void);
        private:
        void RunL(void);
        void DoCancel (void);
        private:
        RSocketServ iSession;
        RSocket     iListen, iSocket;
        CRx*        iRxAO; // 用于接收数据的活动对象
        CTx*        iTxAO; // 用于发送数据的活动对象
        };

请注意，在成员变量中有两个socket，一个是用来监听和连接的，而另外一个是用来处理和客户端之间进行数据的传输的。

在这个类的定义中，还有两个活动对象，他们是iRxAO和iTxAO。这两个活动对象用来在连接到服务之后异步地、分别地处理数据的发送和接收工作。

(对上面已经定义的类而言，这个类仅仅接收一个客户端连接，那么请你不要对自己的创造力作任何限制地去想象和学习一下吧，你可以以这个类定义为基础，将他扩展为接收多个客户端连接的服务器吧!)

下面我们来看看连接过程是如何实现的。

做好接收客户端连接的准备

首先，在我们的服务器没有进行服务接入请求之前，我们要先创建两个socket，创建方法如下所示：

// Need to use two sockets - one to listen for
        // an incoming connection.
        err = iListen.Open(iSession, KAfInet,KSockStream, KUndefinedProtocol);
        User::LeaveIfError(err);
        // The second (blank) socket is required to
        // build the connection & transfer data.
        err = iSocket.Open(iSession);
        User::LeaveIfError(err);

一个socket叫做iListen，他扮演的就是‘监听者’的角色，用来监听是否有来自客户端的接入请求。iListen是一个和协议流关联的对象，在本例中这个协议就是TCP协议，因为我们使用的是Internet地址格式。

另外一个socket，叫做iSocket，在现在是被构造为空socket的，它仅仅在客户端连接请求的时候才会被准备好进入工作状态。这个socket就是用来处理来自客户端的任何请求，并且进行数据传输工作的。

那么下面，监听socket就可以去进行监听客户端连接请求的工作了。

请注意上面例子中使用的两个不同的RSocket::Open()函数的多态。

其中第一个，用在iListen成员变量的，它是用来进行客户端请求连接监听的，所以它需要一个本地地址，只有这样连接数据才能本正确地路由到该对象。

要设定本地地址，我们需要将一个地址和一个socket进行绑定（bind）操作：

// Bind the listening socket to the required
        // port.
        TInetAddr anyAddrOnPort(KInetAddrAny, KTestPort);
        iListen.Bind(anyAddrOnPort);

在本例中，我们并没有过多考虑socket的网络地址，因为我们使用的是易于操作的主机地址名称。尽管如此，我们还是需要指定端口号，这样才能完整确定一个绑定地址。

这个时候，客户端就可以通过我们的主机的Internet主机地址和端口号（事先在程序中用#define宏定义好了的KTextPort）向我们的主机（服务器）发送请求了。不过有一点，如果我们不向客户端告知我们的主机名称和端口号，那么客户端将永远无法访问到我们的服务器。

还要注意，因为我们的socket是使用Internet地址格式协议族进行打开操作的，所以我们调用Bind()函数时送入的函数参数TSockAddr就是一个TInetAddr类型的一个实例。

在TInetAddr类中，它除了保存TSockAddr中定义的一般性数据值外，还保存了一个TUint32类型的IP地址数据。在协议族属性中，TInetAddr类提供的永远是KAfInet值，因为该值表示这个地址是一个TCP/IP地址。

当完成了socket的建立，绑定了监听socket，我们就几乎完成了所有准备工作，可以相应来自任何客户端的连接请求。

下面我们就是需要把接入连接请求创建一个队列，这个时候我们需要调用RScocket::Listen()函数，另外还要注意我们应该使用长度为1的队列，之后我们看到连接是如何进行的时候，就会明白这个队列长度是足够了的。

void CModel::StartEngineL (void)
        {
        …
        // Listen for incoming connections...
        iListen.Listen(1);
        // and accept an incoming connection.
        // On connection, subsequent data transfer will
        // occur using the socket iSocket
        iListen.Accept(iSocket, iStatus);
        SetActive();
        ...
        }

最后，我们调用异步函数RSocket::Accept()来准备接收客户端连接请求。

那么我们再来回顾一下继承自活动对象CActive类的CModel类，当一个客户端连接到我们定义的服务器类的时候，CModel::RunL()函数将会被调用。

该函数被调用后的过程，请看下一部分。

处理连接请求

当一个客户端连接请求被收到的时候，最前线的RSocket::Accept()函数执行请求完成，然后活动对象的RunL()函数将会被调用，这一切步骤都是因为CModel类是一个被激活状态的活动对象。

    void CModel::RunL(void)
        {
        if (iStatus==KErrNone)
        {
        // Connection has been established
        NotifyEvent(EEventConnected);
        // Now need to start the receiver AO.
        iRxAO->RxL(iSocketType);
        }
        else // error condition
        ...
        }
        

那么假设现在所有步骤都是正常进行，那么我们获得的完成状态变量就是KErrNone。在上面的范例代码中，我们会向用户界面层传递一个连接建立成功的消息，然后我们启动活动对象，对接收到的数据进行处理，然后连接iSocket进行返回数据的准备。

因为我们进行操作的是一个异步系统，所以现在因为客户端和服务器是已经连接的状态，那么客户端可以在任何时间向服务器socket发送数据。所以我们需要在接收到数据之后，尽可能快地进行数据的处理。

有一点，在我们进行已连接的socket的数据发送的时候，我们并不会打开活动对象。数据仅仅会在客户端程序或者用户希望发送数据到客户端的时候，才进行操作。

使用有连接的socket

回顾一下我们前面定义的CModel类，我们有一个成员变量，类型为CRx的iRxAO。

类CRx是一个继承自CActive的类，他也是一个活动对象。

CRx类的成员函数RxL()，定义如下；这个函数向连接到我们的服务器的客户端发出了一个一个异步请求。

    void CRx::RxL ( ) //class CRx derived from CActive
        {
        // Issue read request
        iSocket->RecvOneOrMore(iDataBuffer, 0, iStatus, iRecvLen);
        SetActive();
        }
        

函数RecvOneOrMore()将会在稍后，和其他一些读取以及写入socket的函数一同进行讨论。

在接入数据请求完成的时候，CRx::RunL()函数将会被调用，完成后返回的内容有完成状态事件以及新收到的数据内容。

那么再来回顾一下CModel类的另外一个成员变量，类型为CTx的iTxAO。

类CTx是一个继承自CActive的类，他也是一个活动对象。

CTx类的成员函数TxL()，如下所示；他想连接到服务器的客户端进行了一个发送数据的一部请求操作。

    void CTx::TxL (TDesC& aData)
        {
        if (!IsActive())
        {
        // Take a copy of the data to be sent.
        iDataBuffer = aData;
        // Issue write request
        iSocket->Send(iDataBuffer, 0, iStatus);
        SetActive();
        }
        }
        

Send()函数将会在稍后，和其他一些读取以及写入socket的函数一同进行讨论。

当数据发送请求完成的时候，CTx::RunL()函数将会被调用，同时返回的内容有发送操作完成的结果状态。

传输数据

现在我们来看看两台网络设备之间，究竟是如何利用socket来进行数据传输的。

如我们以前所知，在socket通信中，数据报通信和数据流通信是两种十分不同的通信方式。

无论我们使用的是数据报还是数据流的传输方式，每一个独立的数据单元在网络通信的两端被传输的时候都有可能经过十分不同的路由路径，因为在网络通信的双方之间总有着不计其数的子网络，而通信双方对数据单元的路由方向是无法控制的。这种情况是十分普遍而且正常的，由于数据流的传输方式也是以数据报形式为基础的，所以从这个角度来看的话，二者的路由特点是一致的。

接收数据

使用无连接的sockets

下面的函数，是RSocket提供的用来接收无连接的socket的接入数据的。

    void RecvFrom(TDes8& aDesc, TSockAddr& anAddr, TUint flags,
        TRequestStatus& aStatus);
        void RecvFrom(TDes8& aDesc, TSockAddr& anAddr, TUint flags,
        TRequestStatus& aStatus, TSockXfrLength& aLen);
        

如果应用程序使用的是无连接的socket，那么需要使用RSocket::RecvFrom()这个这个方法来读取从另外一个远程主机发送过来的数据。

该函数的第一个参数是一个字符串，是用来保存接收数据的。

调用该函数的程序，会在一个完整的数据报接收完成的时候，得到相应的通知。接收数据的长度，就是接收字符串的长度。如果接收数据报的长度要比字符串的最大长度更长，那么接收数据的末尾将被截去。

该函书的第二个参数是要进行接收操作的远程主机的地址。这个地址需要是一个根据socket打开方式定义的协议格式相匹配的地址。例如，如果打开socket的时候定义的是TCP/IP协议，那么这个地址需要是一个TInetAddr类型的变量。

我们会发现，这个函数有两个版本的重载，他们都进行了同样的操作，方式也一样。唯一不同的是，第二个函数可以将接收数据的长度，显式地返回给调用者。

还有一点，一个单独的socket在任何一个时间内，都只有一个状态为等待中的接收操作。

上面的方法，只能用于无连接（数据报）类型的socket连接。

使用连接的sockets

下面的函数是RSocket提供的用来从已经连接的socket中读取数据的函数原形。

    void Recv(TDes8& aDesc, TUint flags, TRequestStatus& aStatus);
        void Recv(TDes8& aDesc, TUint flags,
        TRequestStatus& aStatus,TSockXfrLength& aLen);
        void RecvOneOrMore(TDes8& aDesc, TUint flags,
        TRequestStatus& aStatus, TSockXfrLength& aLen);
        

如果应用程序使用的是已连接的socket，那么应该使用上面的函数来进行远程主机的数据接收工作。

和前面的无连接socket类似，这些接收函数的第一个参数，仍然是接收数据要保存的目标字符串变量。

Recv()函数会在目标字符串变量被填满或者连接断开的时候完成。在该函数完成调用的时候，读取数据的长度就是字符串的长度，除非在没有读取任何数据连接就断开了。

第二个Recv()函数的重载可以显式地获取接收数据的长度，该长度被保存在了类型为TSockXfrLength的函数参数中，这样的话判断接收数据长度就不必关联接收字符串的长度了。

最后一个函数RecvOneOrMore()，与Recv()不同，这个函数是会在函数接收到任何数据之后立刻返回的。言外之意，调用RecvOneOrMore()函数会接收到1--n个字节，其中n就是目标字符串的长度。同样地，如果连接被断开，RecvOneOrMore()函数仍然会立刻返回，并且不会返回任何数据。

虽然是已连接的socket，但是在发送过程中数据流并不一定都是物理上连续的，尽管从逻辑上看他们是流式的。所以，即便是使用已连接的socket，仍然应用程序--socket的调用者--来进行判断数据流的结束与否，边界切分等工作。

注意，由于我们使用的是已连接的socket，那么我们不需要指定接收收据的socket地址，因为已连接的socket是在连接动作发生的时候就已经指定好了传输目标主机地址信息了。

在这一部分的前半部分，我们介绍的各种函数都是具有比较高的复杂度的，可能对于应用程序开发者来说并不会具有特别的吸引力。

特别地，我们可以注意到所有的函数都以一个参数TUint aFlags作为标示作用，到目前为止还没有对他进行讨论。这个参数的作用是让应用程序可以选择特定协议的指定属性，以此来设置协议接收处理数据的方式。

下面介绍的另外一个函数Read()，他将默认标示参数设置为0，并且也去掉了TSockXfrLength类型的参数。如果使用该函数，那么接收数据的长度就只能通过接收目标字符串的长度来获得了。

     void Read(TDes8& aDesc, TRequestStatus& aStatus);
        

除了上述的两个例外，这个Read()函数的操作效果就基本同Recv()一样了。

注意，这个函数仅仅在已连接的socket通信中是可以使用的。

发送数据

使用未连接的sockets

下面的函数是RSocket中用来向未连接的socket发送数据的。

    void SendTo(const TDesC8& aDesc, TSockAddr& anAddr, TUint flags,
        TRequestStatus& aStatus);
        void SendTo(const TDesC8& aDesc, TSockAddr& anAddr, TUint flags,
        TRequestStatus& aStatus, TSockXfrLength& aLen);
        

如果应用程序连接的是无连接的socket，那么就要使用RSocket::SendTo()函数来向远程主机发送数据。

这个函数中的第一个参数是包含了要发送数据内容的字符串，而要发送内容的长度，则是由字符串的长度决定的。

当数据发送完成的时候，调用该函数的应用程序将会得到通知。如果你使用的是带有TSockXfrLength类型参数的函数重载，那么已发送的数据的长度，将会在完成的时候被保存在该参数中。

第二个参数包含了要发送数据的远程主机的地址，这个地址的格式应该符合socket被打开的时候制定的协议所支持的地址格式，比如，如果我们选择了TCP/IP协议，那么我们就需要使用TInetAddr作为发送主机的地址。

第三个参数，TUint类型的标志位，它是一个和协议相关的位标识符，定义了某些需要向协议模块中传递参数的标志信息。

需要注意的是，在一个socket连接中，在任意时间最多仅有一个发送操作时处于等待状态的。

上述介绍的函数，仅仅可用于无连接的数据报socket使用。

使用连接的sockets

下面的函数，是RSocket提供的用来向一个已经连接的socket发送数据的。

    void Send(const TDesC8& aDesc, TUint someFlags,
        TRequestStatus& aStatus);
        void Send(const TDesC8& aDesc, TUint someFlags,
        TRequestStatus& aStatus, TSockXfrLength& aLen);
        

如果你的应用程序使用的是已经连接的socket，那么可以使用上面的函数来向远程主机发送数据。

和上面类似，该函数的第一个参数是包含了要向远程主机发送数据内容的字符串，该字符串的长度就是要发送数据的全部长度。

Send函数会在全部数据源发送完成之后，或者连接断开之后返回。

第二个函数Send()可以让调用者传递一个TSockXfrLength类型的参数进来，以此来确定发送数据的长度，这样的话传输函数就不必以发送数据的内容的字符串长度来作为原数据的长度了。

上面两种函数冲在，都提供了一个TUint someFlags参数，该参数是用来定义和协议相关的标示位的，针对不同协议会有不同的协议标示定义。

正如前面提到的SendTo()函数，上面第二个方法中的TSockXfrLength类型的参数，会在异步调用请求完成的时候，被赋予已经发送的数据的长度。

请注意，因为我们是在向已经连接的socket发送数据，所以我们并不需要指定目标主机地址。对于已经连接的socket来说，在socket打开的时候，远程主机地址就已经被指定好了。

我们目前所提供的函数，可能对于应用程序的开发者来说还是有些过于复杂，并且更深入一些。

对于下面提供的Write函数来说，所有的标志标示符都被去除，他们将使用默认值0。另外TSockXfrLength也被去除了，这样的话，发送函数就仅仅从发送数据内容的字符串中获得发送数据的长度了。

    void Write(const TDesC8& aDesc, TRequestStatus& aStatus);
        

除了上面说到的两个不同点之外，其它部分都是和Send()函数几乎没有差别的。

注意，这里提到的发送数据的函数，都仅仅适用于已经连接的socket。

总结

本文提供了一些Symbian OS的socket服务编写说明，以及如何将通信功能加入到应用程序中。

Socket服务组件通过两个主类RSocketServ和RSocket，提供了一个近乎标准Socket API的接口。 RSocketServ是连接到sockets服务的回话进程，而RSocket是连接到sockets服务的子会话。通过这两个类，你可以实现面向连接或者无连接的socket。主机解析服务可以通过RHostResolver类来完成。

Socket服务组件的设计是基于协议模块的，不同的插件模块实现了在Socket通信中的不同协议的细节部分。这种设计可以使Socket服务组件可以支持未来的通信协议，而并不对服务组件进行升级。到Symbian OS 6.0为止，被支持的协议包括 TCP/IP（网络控制协议和互联网协议）, IrDA（红外）, SMS（短信） and Bluetooth® （蓝牙无线技术）.

致谢: 本文是于2005年从www.symbian.com的开发文章部分引用于此的, 本文的作者是Gavin Meiklejohn。目前指向这篇文章的链接已经不再有效，所以此处再次发布这篇十分有价值的文章。

方法1(推荐)把这个变量定义成AppUi类的私有成员，在创建view时将这个变量传引用（或传指针）到view中，这样view就能随时访问它了。

方法2.把这个变量定义成AppUi类的私有成员，并为它写公共的访问函数
// CMyAppUi
public: // new methods
   TInt Share(); // return iShare
private:
JAVA手机网[www.cnjm.net]   TInt iShare;
在View里通过下面的方式访问这个变量：
// 如果View继承自CAknView
CMyAppUi* appUi = static_cast<CMyAppUi*>(AppUi());
appUi->Share(); // :)
// 如果View是其它类型
CMyAppUi* appUi = static_cast<CMyAppUi*>(CCoeEnv::Static()->AppUi());
appUi->Share(); // :)
方法3.使用单态类，参考诺基亚论坛上的文档：
Tip Of The Month: How To Implement A Singleton Class In Symbian OS

How to implement a singleton class in Symbian OS        ID: TTS000222

Version 1.1
Published at www.forum.nokia.com on October 19, 2006.

Overview

The singleton pattern is one of the best-known patterns in software engineering. Essentially, a singleton is a class which only allows a single instance of itself to be created, and usually gives simple access to that instance.

How to use thread local storage (TLS) to implement a singleton class

In Symbian OS, each DLL that is loaded in each thread has a machine word of thread-specific memory that can be written to and read — but no other static memory, which is why you can't have static class member variables. Since static class member variables are usually used to implement the singleton pattern, in Symbian OS we have to get around this, for instance by using TLS.

The following code demonstrates a singleton object whose NewL function uses TLS to test whether an object of its own type has been created. If it has, it simply returns the pointer stored in TLS, converted to its own type. If not, it instantiates an object of its own type, stores it in TLS, and then returns it.

Note that this assumes that no other class in the DLL that includes this class uses TLS. If this is not the case, you must write a singleton manager class, which uses TLS to store a pointer to a structure of pointers to all the singleton classes that the program needs.

Example 1: Singleton implementation based on TLS

  ==============

  CMySingleton.h

  ==============

  class CMySingleton : public CBase

      {

  public: // constructor and destructor

      static CMySingleton* NewL();

      virtual ~CMySingleton();

  private: // constructors

      CMySingleton(); // private because of the singleton pattern; it is

                      // guaranteed that only NewL will call it

      void ConstructL();

  public: // other functions

      ...

  private: // other functions

      ...

  private: // data

      ...

      }

  ================

  CMySingleton.cpp

  ================

  CMySingleton::CMySingleton* NewL()

      {

      CMySingleton* singleton;

      // Check thread local storage:

      if ( Dll::Tls() == NULL )

          {

          // TLS is still null, which means that no CMySingleton has

          // been instantiated yet.  Do so now, and return that

          // instance:

          singleton = new ( ELeave ) CMySingleton();

          CleanupStack::PushL( singleton );

          singleton->ConstructL();

          CleanupStack::Pop( singleton );

          // Store a pointer to the new instance in thread local storage:

          TInt err = Dll::SetTls( static_cast<TAny*>( singleton ) );

          if ( err == KErrNone )

              {

              return singleton;

              }

          else

              {

              delete instance;

              User::Leave( err );

              return NULL;

              }

          }

      else

          {

          // CMySingleton has been instantiated once already, so return

          // that instance:

          singleton = static_cast<CMySingleton*>( Dll::Tls() );

          return singleton;

          }

      }

TLS on S60 3rd Edition

Since applications from S60 3rd Edition onwards are implemented as EXE programs, Dll::Tls() is not available anymore. Instead, TLS functionality is implemented in UserSvr class (e32svr.h):

static TInt DllSetTls(TInt aHandle, TAny *aPtr);

static TAny *DllTls(TInt aHandle);

static void DllFreeTls(TInt aHandle);

Note that EXE programs can contain writeable static data, but this is not recommended to be used except as a last resort.

Using class CCoeStatic to implement a singleton class

A simpler way of implementing singletons than using TLS is possible for those classes which use the CCoeEnv class. Since CCoeEnv is a part of the UI control framework, this concerns only applications, not application engines.

This applies also to S60 3rd Edition and later editions.

Example 2: Singleton implementation based on CCoeStatic

  ==============

  CMySingleton.h

  ==============

  /**

   * Example implementation of a singleton class by means of inheriting

   * from CCoeStatic.

   */

  class CMySingleton : public CCoeStatic

      {

  public: // constructors and destructor   

      /**   

       * Returns an instance of this class. When called for the first

       * time, a new instance is created and returned.  After that,

       * calling InstanceL returns the same instance that was created

       * earlier.

       *  

       * @return A pointer to a CMySingleton object   

       */   

      static CMySingleton* InstanceL();   

  private: // constructor

      /**   

       * Default constructor is private because we are using the

       * singleton design pattern.

       */   

      CMySingleton();   

      ...

      }

  ================

  CMySingleton.cpp

  ================

  // -------------------------------------------------------------------------

  // CMySingleton::CMySingleton

  // C++ default constructor. It is private because we are using the

  // singleton design pattern.

  // -------------------------------------------------------------------------

  CMySingleton::CMySingleton()

      : CCoeStatic( KUidMySingleton )

      {

      }

  // -------------------------------------------------------------------------

  // CMySingleton::InstanceL

  // Returns an instance of this class. When called for the first time,

  // a new instance is created and returned.  After that, calling

  // InstanceL returns the same instance that was created earlier.

  // Note that the UID passed to CCoeEnv::Static needs to be unique.

  // -------------------------------------------------------------------------

  CMySingleton* CMySingleton::InstanceL()

      {

      CMySingleton* instance = static_cast<CMySingleton*>

          ( CCoeEnv::Static( KUidMySingleton ) );

      if ( !instance )

          {

          instance = new ( ELeave ) CMySingleton;

          CleanupStack::PushL( instance );

          instance->ConstructL();

          CleanupStack::Pop();

          }

      return instance;

     }

    本常见问题问答由 WoSign 根据 Forum Nokia(诺基亚开发者论坛)以下文章翻译整理，请同时参考英文原文： http://forum.nokia.com/main/technical_services/testing/index.html
http://forum.nokia.com/main/technical_services/testing/application_testing_faq.html
http://seap.forum.nokia.com/main/platforms/s60/faq.html
http://seap.forum.nokia.com/main/technical_services/testing/symbian_signed_benefits.html
以及 Symbian Signed 认证常见问题问题

    软件测试是一个应用软件开发过程中最主要的环节，一般包括模块测试、系统测试、可用性测试和权威认证测试 ( 如： Symbian Signed 认证测试和 Java Veriified 认证测试 ) 。所有通过诺基亚销售渠道推广的移动应用软件都必须通过 Symbian Signed 认证测试或 Java Veriified 认证测试。请同时参考 诺基亚测试标准和其他重要文档 。

    Symbian Signed 认证已经成为移动应用软件测试和认证的事实工业标准，采用业界广泛接受的软件质量规范来推动基于 Symbian 操作系统的应用软件的开发和内容的开发。 测试和认证主要是为了保证 Symbian 开发平台的安全和最终用户的更加安全。从 Symbian 操作系统 V9.x(S60 第 3 版 ) 开始，“ capability( 能力 ) ”模式限制了许多敏感 API 的访问，一些“能力”只能通过 Symbian Signed 认证才能获得，而有些“能力”还需要手机厂商的认证。

    Symbian Signed 认证主要流程如下图所示，首先在 Symbiansigned.com 网上注册用户，再申请购买 TC Publisher ID 认证证书，再签名 SIS 文件，再提交已经签名的文件给 Symbian Signed 指定的测试公司测试，测试通过后从 Symbiansigned 网站取回由测试公司重新签名的文件，就可以部署到手机中安全运行了。
    请注意：通过测试取回的文件已经重新使用手机所信任的 Symbian 根证书下颁发的 Symbian Signed 证书签名，请不要再修改此软件，也不得重新使用您的认证证书签名，否则不能正常运行。

1. S60 第 3 版的应用软件签名是强制要求吗？

答：是的。 S60 第 3 版的应用软件是必须要数字签名才能运行的，是强制要求。请注意：数字签名与测试认证是两码事，数字签名是必须的，而测试认证不是必须的。您可以使用自签证书 (SDK 生成 ) 签名，或使用 TC Publisher ID(Symbian Signed 认证证书 ) 来签名应用软件。

2. 自签证书、 Symbian 开发者证书 (Symbian developer certificate) 和 Symbian 认证证书 (TC Publisher ID) 三者有什么不同？签名后的效果有什么不一样？

答：对于 S60 第 3 版，应用软件签名是必须的，否则不能成功安装到手机上。如果应用软件不需要任何能力 (capability) ，则可以使用 SDK 生成自签证书；如果应用软件需要能力，则在软件开发和自测过程中需要申请 Symbian 开发者证书来签名应用软件；而对于最终发布的商用应用软件，有些能力必须通过 Symbian Signed 认证来授权，只有通过 Symbian Signed 认证才能访问某些能力。同时，手机厂商或移动运营商的应用软件市场推广也要求应用软件已经通过 Symbian Signed 认证。

三种证书签名后的效果不同在于：

(1) 使用自签证书签名

    •  可以使用 SDK 带的工具来生成自签证书或直接使用 Carbide 中的自签证书；
    •  签名后可以安装应用软件，但有警告；
    •  只具有有限的能力，仅包括： ReadUserData, WriteUserData, NetworkServices, LocalServices 和 UserEnvironment

(2) 使用开发者证书签名

    •  可以签名 SIS 文件包
    •  应用软件具有 14 种能力，可以申请其他能力
    •  仅用于开发过程调试，有测试手机数量限制

(3) 通过 Freeware 认证

    •  开发者通过 Symbian Signed Freeware 认证通道提交应用软件获得认证 ( 如果软件通过测试 )
    •  应用软件具有 14 种能力，可以申请其他能力
    •  不得用于商业目的 

(4) 通过 Symbian Signed 认证

    •  开发者通过 Symbian Signed 认证通道提交应用软件获得认证 ( 如果软件通过测试 )
    •  应用软件可以有所有能力

(5) 自我认证 (Self Certified)

    •  开发者从 Symbian 获得自我认证资格，自己测试和签名应用软件
    •  应用软件可以有所有能力

3. 为何我需要购买 TC Publisher ID ( Symbian Signed 认证证书 )?

答：如果您要申请 Symbian Signed 认证，则一定要先购买 TC Publisher ID (免费软件Freeware开发者除外) 。在提交 Test house 测试之前，您需要使用 TC Publisher ID 签名 SIS 文件，用于保证软件确实来自软件开发商和不会在发送过程中被非法篡改。

    如果您需要申请支持某些重要的能力的 Symbian 开发者证书，也需要先有 TC Publisher ID 。如果您希望在多款手机上测试您的应用软件，也需要先有 TC Publisher ID( 仅针对 S60 第 3 版 ) 。

4. Symbian Signed 认证证书 (TC Publisher ID) 和 Symbian Signed 测试费用如何？

答： Symbian Signed 认证证书 (TC Publisher ID) 费用为 US$200( 人民币 1600 元 )( 原 VeriSign ACS Publisher ID 价格为 US$350/ 人民币 2800 元 ) 。 WoSign 为 TC Trustcenter 唯一指定的中国区销售代理商 、辅助身份验证机构和中文技术支持中心。

    不同的应用软件测试费用不一样，请参考： Test House information 有详细的收费说明。此测试费用与其他类似测试服务来讲是非常优惠的，而且 Symbian 正在努力降低此费用，将会推出新的测试工具软件来进一步降低测试费用。
    WoSign 推荐用户联系Test House： MphasiS，主要考虑到3家测试公司中只有该公司在上海有办事处，方便用户中文联系，同时其测试费用也是3家测试公司中最便宜的(网上公开价格为：185欧元，约2000元)。具体联系信息如下：Atlas Wang， Tel: 021-5080 7360， Fax: 021-5080 7362， Email: wang.hao@mphasis.com 。

5. 什么是 Symbian 开发者证书？我什么时候需要开发者证书？

答：如果您需要某些能力并需要在一台手机上测试，则您需要在 Symbian Signed 网站(Request DevCerts)申请 Symbian 开发者证书 ( 仅针对 S60 第 3 版 ) 。请参考Symbian Signed网站提供的 "Symbian开发者证书申请流程(中文)" 申请开发者证书。请注意： Symbian 开发者证书只能在申请时指定的手机上测试使用。申请条件依据希望在多少台手机上测试和希望获得哪些能力而不同，具体规定如下表：

6. Symbian Signed 认证证书 (TC Publisher ID) 和 Symbian 开发者证书有效期为多长？

答： TC Publisher ID 有效期为一年，而开发者证书有效期为 6 个月。在申请开发者证书和使用开发者证书签名时，请确保您的 TC Publisher ID 是在有效期内的。您可以双击证书文件 (.cer) 查看证书有效期。如果TC Publisher ID 认证证书已经过期，请重新购买新证书。

7. 我如何知道自签证书签名的应用软件使用了哪些能力？

答：如果应用软件要求某些能力，则在安装过程中会显示如下图示信息(不同的软件可能显示不同的信息)，询问用户是否允许(由于本文从英文原文翻译，没有中文显示信息，请参考您的手机的中文警告信息，以下同)。
    是否允许应用软件：
        - 使用连接功能 ( 能力 = LocalServices )
        - 读取用户数据 ( 能力 = ReadUserData )
        - 写入用户数据 ( 能力 = WriteUserData)
        - 使用照相机或麦克风 ( 能力 = UserEnvironment)
        - 网络访问或发起电话呼叫 ( 能力 = NetworkServices)

8. 如果一个应用软件已经签名，如何显示已经签名的应用软件？

答：使用不同的签名证书签名，会显示不同的警告信息：

(1) 使用自签证书签名

显示“安全警告：应用软件不可信任，也许会损害您的手机”

(2) 通过 Freeware 认证

下图已经涂掉 Freeware 的名称，显示“此应用软件为免费软件，不得用于商业销售。如果您已经付款购买，请发 Email 到： symbiansigned@symbian.com ，并告之您从哪里获得此软件。 ”

(3) 使用开发者证书签名

显示“此应用软件处于开发测试阶段，如果您继续安装此软件可能会带来损害您的手机，要继续安装吗？”而一旦用户选择继续安装，则不会有其他安全警告。

(4) 通过  Symbian Signed 认证

不仅没有任何安全警告，而且不需要用户确认和同意应用软件中使用的能力，大大简化安装和方便用户使用。

9. 我如何知道我的 S60 第 3 版应用软件需要哪些能力？

答：在 S60 第 3 版开发包的帮助文档中有详细说明调用哪些 API 需要什么能力，您可以通过 S60 仿真器来得到确认。当选中“ Enable EPOCWIND,OUT Logging ”和在 epoc.ini 中设置 PlatSecDiagnostics 为 ON 时，仿真器将在 Windows 临时目录中生成一个名为 epocwind.out 的文件，此文件中包含了应用软件所需要的能力信息。

10. 我的应用软件在访问某些 API 或函数时要求Nokia Vendor ID，如何得到Nokia Vendor ID？

答： Nokia Vendor ID(VID) 用来保护系统的敏感区域，是 NOKIA 专用的，不会对任何其他方开放。也就是说，您不能访问需要 VID 的 API 或函数。

11. 我的应用软件需要播放和录制音频和视频，需要有 MultimediaDD 能力吗？

答：不需要，除非您需要修改缺省的系统权限。

12. 我的应用软件需要从收件箱中读取附件，需要有 AllFiles 能力吗？

答：不需要。在消息库中有一个类 MmsvAttachmentManager 可以原来完成此任务。

13. 我的应用软件需要从文件系统中移动 / 删除 / 复制文件，需要有 AllFiles 能力吗？

答：从一般目录 ( nondata-caged ) 中移动 / 删除 / 复制文件不需要。只有从 Data-caged 目录 ( 如： /sys/bin, /private, 和 /resource ) 才需要。

14. 如果要调用 FEP (Front End Processor), MTM (Message Type Module), or browser plug-in ，需要有 哪些 能力吗？

答：需要 ALL - TCB (All minus TCB) 能力。

15. 我无法安装 Symbian SIS 文件到 Symbian OS v9.x 手机上，应该怎么办？

答： 如果您的应用软件是通过 Symbian Signed 认证的，请检查 S60 手机上的“工具” -> “设置” -> “安全” -> “证书管理”中是否有 Symbian B 根证书，并检查手机日期和时间是否设置正确，同时检查手机 SIM 卡是否插入和工作正常。

16. 我们应用软件已经通过某款手机 (S60 第 2 版或 S40) 的 Symbian Signed 认证测试，是否可以在其他 S60 或 S40 手机上安装？

答：安装应该是没有问题的。但如果您的应用软件仅通过某款手机的测试，则不能保证在其他手机上工作正常，推荐重新针对其他目标手机做测试。请注意：基于 S60 第 1 版和第 2 版开发的应用软件不能在第 3 版手机上安装，需要使用相应的 SDK 重新编译您的软件。

17. 什么是 UID ？我如何得到 UID?

答： Unique Identifier (UID) 是系统为二进制文件 (EXE 或 DLL) 分配的唯一识别符，是为了防止可执行文件的相互干扰。对于 S60 第 3 版应用软件需要重新申请 UID ，请参考： www.symbiansigned.com -> UIDs

18. 我需要从 protected range 还是 unprotected range 申请 UID?

答：下表能解释什么情况下需要什么 UID range ，取决于您的应用软件是使用什么证书签名的：

19. 我如何在 S60 第 3 版手机上备份和恢复我的应用软件？

答： S60 第 3 版缺省是不支持备份的，但您可以使用如下办法备份和恢复您的应用软件：

创建一个 XML 备份注册文件： backup_registration.xml

<?xml version="1.0" standalone="yes" ?>
<backup_registration>
    <system_backup />
</backup_registration>

把 "backup_registration.xml" 包括到您的项目包文件中 project .pkg ：

"backup_registration.xml"-
"!:\private\98765432\backup_registration.xml"

S60 3rd Edition

• 详细描述

S60应用程序在前台时，可以设置导航条显示自定义图标或文本。

首先，我们要获得一个状态栏的引用。然后可以从中获得导航栏的引用。应用程序可以使用CAknNavigationDecorator类生成一个基于文本的Navi decorator对象。最后这个对象需要添加到导航栏中以便开始显示：

//------------------------------------------------------------------------------
 
CAknNavigationControlContainer* iNaviPane = 0;
 
CAknNavigationDecorator* iNaviDecorator = 0;
 
//Get the reference of the status pane
 
CEikStatusPane *statusPane = iEikonEnv->AppUiFactory()->StatusPane();
 
if ( statusPane )
 
{
 
//Get the reference of the navi pane
 
iNaviPane=static_cast<CAknNavigationControlContainer*>(statusPane->ControlL(
 
TUid::Uid(EEikStatusPaneUidNavi)) );
 
//Create a Navi decorator object
 
iNaviDecorator= iNaviPane->CreateEditorIndicatorContainerL();
 
//Get the reference of the indicator container inside the NaviDecorator
 
CAknIndicatorContainer* indiContainer =
 
static_cast<CAknIndicatorContainer*>(iNaviDecorator->DecoratedControl());
 
if ( indiContainer && CEikStatusPaneBase::Current() )
 
{
 
TBuf<32> msgSize;
 
msgSize.Append(_L("Test")); // Text to be displayed
 
 
indiContainer->SetIndicatorValueL(
 
TUid::Uid( EAknNaviPaneEditorIndicatorMessageLength ), msgSize );
 
 
indiContainer->SetIndicatorState(
 
TUid::Uid( EAknNaviPaneEditorIndicatorMessageLength ),
 
EAknIndicatorStateOn);
 
}
 
 
 
//Push the object onto the navi pane.
 
iNaviPane->PushL( *iNaviDecorator );
 
}
 
//------------------------------------------------------------------------------

下面的这个示例代码，演示了如何在导航栏中显示一个图标：

//------------------------------------------------------------------------------
 
CFbsBitmap* bitmap = NULL;
 
CFbsBitmap* mask = NULL;
 
CEikStatusPane* statusPane = iEikonEnv->AppUiFactory()->StatusPane();
 
CAknNavigationControlContainer* naviPane =
 
(CAknNavigationControlContainer*)statusPane->ControlL(
 
TUid::Uid(EEikStatusPaneUidNavi));
 
// Create an icon
 
AknIconUtils::CreateIconLC (bitmap, mask, KIconFile,
 
EMbmCarsvgCircle, EMbmCarsvgCircle_mask); //KIconFile is the .mif file
 
 
TSize size(30,30);
 
AknIconUtils::SetSize(bitmap, size); // Sets the size of the extracted image
 
//Create a Navi Decorator encapsulation for the image.
 
CAknNavigationDecorator* naviDecorator =
 
naviPane->CreateNavigationImageL(bitmap, mask);
 
//Push the image onto the navi pane.
 
naviPane->PushL(*naviDecorator);
 
//------------------------------------------------------------------------------

需要的头文件及库文件有：

#include <aknnavi.h>               // for CAknNavigationControlContainer
 
#include <eikspane.h>              // for CEikStatusPane
 
#include <aknnavide.h>             // for CAknNavigationDecorator
 
#include <akniconutils.h>          // for AknIconUtils
 
#include <aknindicatorcontainer.h> // for CAknIndicatorContainer
 
LIBRARY     aknicon.lib
 
LIBRARY     fbscli.lib
 
LIBRARY     avkon.lib

注意：程序在前台时这些导航栏上的文字和图标才得以显现，但手机待机时却不会处理。

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1822893

  inline TUint8 GetG(const TUint16 aColor)
  {
  return aColor;
  }

  inline TUint8 GetB(const TUint16 aColor)
  {
  return aColor & 0xf;
  }

CFbsBitmap* CinfoshowContainer::BmpZoomL( CFbsBitmap* aBitmap, TInt aWinth, TInt aHeight)
{
 if( aWinth>0 && aHeight>0 )
 {
  const TInt widtha = aBitmap->SizeInPixels().iWidth;
  const TInt heighta = aBitmap->SizeInPixels().iHeight;
  TReal WPencent=(TReal)aWinth/widtha;
  TReal HPencent=(TReal)aHeight/heighta;
  return BmpZoomL( aBitmap, WPencent, HPencent);
 }
 else
 {
  return NULL;
 }

}
CFbsBitmap* CinfoshowContainer::BmpZoomL( CFbsBitmap* aBitmap, TReal aPencent ){
 if(aPencent>0)
 {
  return BmpZoomL( aBitmap, aPencent, aPencent );

 }
 else
 {
  return NULL;
 }
}
CFbsBitmap* CinfoshowContainer::BmpZoomL( CFbsBitmap* aBitmap, TReal aWPencent, TReal aHPencent)
{
 if( aWPencent>0 && aHPencent>0 )
 {
 
  const TInt widtha = aBitmap->SizeInPixels().iWidth;
  const TInt heighta = aBitmap->SizeInPixels().iHeight;
  const TInt width = widtha * aWPencent +0.5;
  const TInt height = heighta * aHPencent +0.5;
  CFbsBitmap* newbitmap = new(ELeave) CFbsBitmap();
  User::LeaveIfError(newbitmap->Create(TSize(width,height), EColor4K/*displayMode*/));

  TBitmapUtil bmpUtil1(aBitmap);
  TBitmapUtil bmpUtil2(newbitmap);
  bmpUtil1.Begin(TPoint(0,0));
  bmpUtil2.Begin(TPoint(0,0), bmpUtil1); 
  
  TUint16* const addr1 = (TUint16*)aBitmap->DataAddress();
  TUint16* const addr2 = (TUint16*)newbitmap->DataAddress();
     
  TUint16* p1 = addr1;     
  TUint16* p2 = addr2;     
  const TInt line1 = CFbsBitmap::ScanLineLength(widtha, EColor4K) / 2; 
  const TInt line2 = CFbsBitmap::ScanLineLength(width, EColor4K) / 2;     

  TReal xa=0,ya=0;
  TInt x=0,y=0;
  const TInt jump = line2 - width;

  TUint16* p2end = addr2 + width;

  p2end = addr2 + line2*height;
  while( p2 < p2end)
  {
   TUint16* p2endline = p2 + width;
   while( p2!=p2endline )
   {
    
    xa=x/aWPencent;
    ya=y/aHPencent;
    TInt xai = xa;
    TInt yai = ya;
    
    if( xai == widtha -1 )
    {
     if( yai == heighta-1 )
     {
      *p2 = *(addr1+line1*yai+xai);
     }
     else
     {
      p1=addr1+line1*yai+widtha-1;     
      
      TUint8 red=GetR(*p1)+(GetR(*(p1+line1))-GetR(*p1))*(ya-yai)+0.5;  
      TUint8 green=GetG(*p1)+(GetG(*(p1+line1))-GetG(*p1))*(ya-yai)+0.5;
      TUint8 blue=GetB(*p1)+(GetB(*(p1+line1))-GetB(*p1))*(ya-yai)+0.5;
      *p2 = (red<<8) | (green&0xf0) | blue;
     }

    }
    else
    {
     if( yai == heighta-1 )
     {
      p1=addr1+line1*(heighta-1)+xai;

      TUint8 red=GetR(*(p1))+(GetR(*(p1+1))-GetR(*(p1)))*(xa-xai)+0.5;  
      TUint8 green=GetG(*(p1))+(GetG(*(p1+1))-GetG(*(p1)))*(xa-xai)+0.5;
      TUint8 blue=GetB(*(p1))+(GetB(*(p1+1))-GetB(*(p1)))*(xa-xai)+0.5;
      *p2 = (red<<8) | (green&0xf0) | blue;
     }
     else
     {
      
      p1=addr1+line1*yai+xai;
      
      TUint8 red1=GetR(*(p1))+(GetR(*(p1+1))-GetR(*(p1)))*(xa-xai)+0.5;  
      TUint8 green1=GetG(*(p1))+(GetG(*(p1+1))-GetG(*(p1)))*(xa-xai)+0.5;
      TUint8 blue1=GetB(*(p1))+(GetB(*(p1+1))-GetB(*(p1)))*(xa-xai)+0.5;
      
      p1=addr1+line1*(yai+1)+xai;
      
      TUint8 red2=GetR(*(p1))+(GetR(*(p1+1))-GetR(*(p1)))*(xa-xai)+0.5;  
      TUint8 green2=GetG(*(p1))+(GetG(*(p1+1))-GetG(*(p1)))*(xa-xai)+0.5;
      TUint8 blue2=GetB(*(p1))+(GetB(*(p1+1))-GetB(*(p1)))*(xa-xai)+0.5; 
      
      TUint8 red=red1+(red2-red1)*(ya-yai)+0.5;  
      TUint8 green=green1+(green2-green1)*(ya-yai)+0.5;
      TUint8 blue=blue1+(blue2-blue1)*(ya-yai)+0.5;
      
      *p2 = (red<<8) | (green&0xf0) | blue;
      
     }
     
    }
    x++;
    p2++;
    
   }
   x=0;
   y++;
   p2+=jump;
   
  }

  bmpUtil2.End();
  bmpUtil1.End();
  
  return newbitmap;
 }
 else
 {
  return NULL;
 }
}
 

使用双线性插值算法实现，支持12位色，缺点是当缩放比例小于0.5时图像较源图偏右下明显。
包含3个重载函数，分别是指定宽高，指定整体缩放比例和指定

可改为支持16位和24位色
16位色RGB的获取和合成，tempcolor为象素点的颜色值TUint16型

TUint8 red= tempcolor>>8;
TUint8 green=tempcolor>>3;
TUint8 blue=tempcolor & 0x1f;

tempcolor=((TUint16)(red&0xf8)<<8) | ((TUint16)(green&0x3f)<<3) | (blue&0x1f);

24位色为3个字节，指针为TUint8*，新图像颜色计算公式示例如下
*p2=(*p1)+((*(p1+line1))-(*p1))*(ya-yai)+0.5; //red
p1++;
p2++;
*p2=(*p1)+((*(p1+line1))-(*p1))*(ya-yai)+0.5; //green
p1++;
p2++;
*p2=(*p1)+((*(p1+line1))-(*p1))*(ya-yai)+0.5;//blue
p1++;
p2++;

2、阻塞提示框

void CEikonEnv::AlertWin(const TDesC& aMsg);
void CEikonEnv::AlertWin(const TDesC& aMsg1,const TDesC& aMsg2);
static void CEikonEnv::InfoWinL(const TDesC& aFirstLine,const TDesC& aSecondLine);

AlertWin为CEikonEnv类的非静态成员函数，InfoWinL为CEikonEnv类的静态成员函数。
AlertWin只能在ui、view和container中使用，使用方法如下：

Code:
iEikonEnv->AlertWin(_L("text"));

InfoWinL可以在任意类中使用，使用方法如下：
Code:
CEikonEnv::Static()->InfoWinL(_L("note:"), _L("text"));

为方便使用，常定义宏来使用这类提示框，如：

Code:
#define DEBUG_DIALOG(x) iEikonEnv->AlertWin(##x);
#define DEBUG_DIALOG1(x) CEikonEnv::Static()->InfoWinL(_L("note:"), ##x);
#define DEBUG_DIALOG2(x,y) CEikonEnv::Static()->InfoWinL(##x, ##y);

可以这么使用：
TBuf<32> buf;
buf.Copy(_L("test"));
DEBUG_DIALOG(buf);
DEBUG_DIALOG1(buf);
DEBUG_DIALOG2(buf,_L("text"));

此类提示框阻塞线程，只有用户按键退出提示框后，后面的程序才能接着运行。

3、进度条对话框

进度条对话框类为：
CAknProgressDialog
头文件：aknprogressdialog.h
lib：avkon.lib   eikcdlg.lib   eikctl.lib

Code:

//初始化进度条
CAknProgressDialog* iProgressDialog;
CEikProgressInfo* iProgressInfo;
iProgressDialog = new ( ELeave ) CAknProgressDialog( reinterpret_cast
                                                        <CEikDialog**>
                                                        ( &iProgressDialog ) );
iProgressDialog->SetCallback( this );
iProgressDialog->PrepareLC( R_RESOURCE_PROGRESS_NOTE );   //从资源文件构造对话框，资源见下面的定义
iProgressInfo = iProgressDialog->GetProgressInfoL();
iProgressInfo->SetFinalValue( aMaxValue );   //设置进度条的最大值（结束值）
iProgressDialog->RunLD();
  
//更新进度条
iProgressInfo->IncrementAndDraw( aStep );  

//结束进度条
iProgressDialog->ProcessFinishedL();
delete iProgressDialog;

RESOURCE DIALOG R_RESOURCE_PROGRESS_NOTE   //进度条对话框资源
     {
     flags = EAknProgressNoteFlags;
     buttons = R_AVKON_SOFTKEYS_CANCEL;
     items =
         {
         DLG_LINE
             {
             type = EAknCtNote;
             id = EMagicBoxCtrlIdProgressNote;
             control = AVKON_NOTE
                 {
                 layout = EProgressLayout;
                 singular_label = "对话框中显示的文字";
                 plural_label = "download";
                 imagefile = AVKON_BMPFILE_NAME;    //第二版中 图标文件为 #define AVKON_BMPFILE_NAME "z:\\system\\data\\avkon.mbm"
                 imageid = EMbmAvkonQgn_note_sml;   //这两项可更改显示不同图标
                 imagemask = EMbmAvkonQgn_note_sml_mask;
                 };
             }
         };
     }

注意：In Series 60 3rd edition, avkon.mbm was replaced by avkon2.mbm and moved to a different location (and the SDK forgot to mention this and still provides erroneous location).
Old entry:
               imagefile = "z:\\system\data\avkon.mbm";
New entry:
               imagefile = "z:\\resource\apps\avkon2.mbm";

4、等待对话框

等待对话框要用到的类：CAknGlobalNote
头文件：aknglobalnote.h
lib：aknnotify.lib eiksrv.lib

Code:

//显示等待对话框
   CAknGlobalNote* globalNote = CAknGlobalNote::NewL();
   CleanupStack::PushL( globalNote );
   TInt iWaitNoteId = globalNote->ShowNoteL( EAknGlobalWaitNote, _L("对话框中显示的文字") );
   CleanupStack::PopAndDestroy();
  
   //结束等待对话框
   CAknGlobalNote * note = CAknGlobalNote::NewL();
   CleanupStack::PushL( note );
   note->CancelNoteL( iWaitNoteId );
   CleanupStack::PopAndDestroy();

注意：
CAknGlobalNote类除了显示等待对话框外还可显示多种类型的全局对话框，具体类型可通过ShowNoteL的第一个参数指定，可能的类型如下：

Code:

enum TAknGlobalNoteType
{
EAknGlobalInformationNote = 1,
EAknGlobalWarningNote,
EAknGlobalConfirmationNote,
EAknGlobalErrorNote,
EAknGlobalChargingNote,
EAknGlobalWaitNote,
EAknGlobalPermanentNote,
EAknGlobalNotChargingNote,
EAknGlobalBatteryFullNote,
EAknGlobalBatteryLowNote,
EAknGlobalRechargeBatteryNote,
EAknCancelGlobalNote,
EAknGlobalTextNote
};

5、询问对话框

询问对话框用到的类：CAknQueryDialog
头文件：AknQueryDialog.h
lib：avkon.lib

Code:

CAknQueryDialog* dlg;
dlg = CAknQueryDialog::NewL( CAknQueryDialog::ENoTone );
dlg->PrepareLC( R_RESOURCE_QUERY_DIALOG ); //从资源文件构造对话框，资源见下面的定义
TInt ret = dlg->RunLD();   //若用户选择“是”，返回非0，选择“否”，则返回0

RESOURCE DIALOG R_RESOURCE_QUERY_DIALOG   //询问对话框资源
     {
     flags = EGeneralQueryFlags;
     buttons = R_AVKON_SOFTKEYS_YES_NO;   //CBA显示“是”和“否”两个按钮
     items =
         {
         DLG_LINE
             {
             type = EAknCtQuery;
             id = EGeneralQuery;
             control = AVKON_CONFIRMATION_QUERY    //表示这是confirm询问对话框，用户选择“是”或“否”
                 {
                 layout = EConfirmationQueryLayout;
                 label = "对话框中显示的文字";
                 };
             }
         };
     }

此类对话框可以有声音提示，由NewL的const TTone& aTone参数指定，可能的值如下：

Code:

enum TTone {
     /// No tone is played
     ENoTone = 0,        
     /// A confirmation tone is played
     EConfirmationTone = EAvkonSIDConfirmationTone,
     /// A warning tone is played
     EWarningTone = EAvkonSIDWarningTone,      
     /// An error tone is played  
     EErrorTone = EAvkonSIDErrorTone         
     };

通过定义不同的询问对话框资源，可实现不同的询问对话框，如让用户输入文字的询问对话框资源定义如下：

Code:

RESOURCE DIALOG R_RESOURCE_DATA_QUERY
   {
   flags = EGeneralQueryFlags;
   buttons = R_AVKON_SOFTKEYS_OK_CANCEL;   //CBA按钮显示“确定”和“取消”
   items =
       {
       DLG_LINE
           {
           type = EAknCtQuery;
           id = EGeneralQuery;
           control = AVKON_DATA_QUERY   //表示这是data询问对话框，需要用户输入内容
               {
               layout = EDataLayout;
               label = "提示内容";
               control = EDWIN
                   {
                   flags = EEikEdwinNoHorizScrolling | EEikEdwinResizable;
                   width = 30;
                   lines = 2;
                   maxlength = 159;
                   };
               };
           }
       };
   }    

Code:

TBuf<128> msg;
CAknTextQueryDialog* dlg = new (ELeave) CAknTextQueryDialog(msg,CAknQueryDialog::ENoTone);
   TInt ret = dlg->ExecuteLD(R_RESOURCE_DATA_QUERY);

用户输入内容后按“确定”，内容就存储到msg中，函数返回非0；按“取消”，函数返回0。

这里用到的类是CAknQueryDialog的子类CAknTextQueryDialog。
CAknQueryDialog的子类有：

Code:

CAknFloatingPointQueryDialog   //This class should be used when user is reguest to enter a flotaing point number
   CAknFixedPointQueryDialog      //...
   CAknDurationQueryDialog        //This class should be used when user is reguest to enter duration
   CAknIpAddressQueryDialog       //This class should be used when user is reguest to enter IP address,@since 2.1
   CAknMultiLineDataQueryDialog   //Query Dialog with data input on more than one line (2 lines at the moment)
                  Create using NewL methods and passing parameters as appropriate.
                  Attention: When deriving from this class, you must call SetDataL during
                  second phase construction.
   CAknMultiLineIpQueryDialog     //...
   CAknNumberQueryDialog          //This class should be used when user is reguest to enter number
   CAknTextQueryDialog            //This class should be used when user is reguest to enter plain text, secret text, phonenumber or PIN-code
CAknTimeQueryDialog            //This class should be used when user is reguest to enter time or date

使用不同的类，资源文件会有所不同。

另外，在资源中定义EDWIN时，可指定输入发，如：

Code:

control = EDWIN
   {
     flags = EEikEdwinNoHorizScrolling | EEikEdwinResizable;
     width = 11;
     lines = 1;
     maxlength = 11;
   avkon_flags = EAknEditorFlagFixedCase |
         EAknEditorFlagNoT9 | EAknEditorFlagSupressShiftMenu;   //EAknEditorFlagSupressShiftMenu屏蔽切换输入法键
   allowed_input_modes = EAknEditorNumericInputMode;
   default_input_mode = EAknEditorNumericInputMode;
   numeric_keymap = EAknEditorPlainNumberModeKeymap;
   };

以上写法表示默认输入法为数字，并且屏蔽了输入法切换键，即不能通过输入法切换键来切换输入法。

6、编辑框

编辑框使用的类：CEikGlobalTextEditor
头文件：eikgted.h

Code:

CEikGlobalTextEditor* iGKeyEd;
TBuf<128> iKeyText;
TResourceReader reader;
iCoeEnv->CreateResourceReaderLC( reader, R_RESOURCE_EDITOR );   //从资源文件构造编辑框，资源见下面的定义
iGKeyEd = new ( ELeave ) CEikGlobalTextEditor;
iGKeyEd->SetContainerWindowL( *this );
iGKeyEd->ConstructFromResourceL( reader );
CleanupStack::PopAndDestroy();   // Resource reader

//设置编辑框的初始文本和位置，编辑框大小在资源中定义
TBuf<32> buf;
buf.Copy(_L("demo"));
iGKeyEd->SetTextL(&buf);
iGKeyEd->SetExtent( TPoint(5,2), iGKeyEd->MinimumSize() );
iGKeyEd->SetFocus(ETrue);
// iGKeyEd->SetReadOnly(ETrue);   //设置编辑框为只读

//使文字居中
CParaFormat      paraFormat; 
TParaFormatMask paraFormatMask;
paraFormatMask.SetAttrib( EAttAlignment );     // set mask
paraFormat.iHorizontalAlignment = CParaFormat::ECenterAlign;
iGKeyEd->ApplyParaFormatL( &paraFormat, paraFormatMask );
  
iGKeyEd->GetText(iKeyText); //获取编辑框中的内容，保存到iKeyText中

RESOURCE GTXTED R_RESOURCE_EDITOR   //编辑框资源  
   {
     flags = EAknEditorFlagDefault;
     width = 53;
     height = 16;
     numlines = 1;
     textlimit= 1;
     fontcontrolflags = EGulFontControlAll;
     fontnameflags = EGulNoSymbolFonts;

//这里也可设置输入法
//    avkon_flags = EAknEditorFlagFixedCase |
                                   EAknEditorFlagNoT9 | EAknEditorFlagSupressShiftMenu;   //EAknEditorFlagSupressShiftMenu屏蔽切换输入法键
//     allowed_input_modes = EAknEditorNumericInputMode;
//     default_input_mode = EAknEditorNumericInputMode;
//     numeric_keymap = EAknEditorPlainNumberModeKeymap;  
   }

注意，要使编辑框正常显示，记得更改container的CountComponentControls和ComponentControl函数，正确处理控件数目和编辑框指针。另外，要使编辑框能正常接收按键事件，要显示调用编辑框的OfferKeyEventL函数，如下：

Code:

TKeyResponse CMobileGuardSetKeyContainer::OfferKeyEventL( const TKeyEvent& aKeyEvent, TEventCode aType )
{
     return iGKeyEd->OfferKeyEventL( aKeyEvent, aType );
}

由于使用多线程来处理异步请求比较消耗系统资源，所以symbian 使用了活动对象（Active Object）来解决异步请求的问题。
活动规划器（active scheduler）用于处理由活动对象提出的异步请求。它检测活动对象提出的异步请求，并安排活动对象的请求完成事件的执行顺序。活动规划器仅用一个事件处理线程来规划各个活动对象提出的事件请求，所以它要比多线程实现异步请求占用更少的资源。
一个活动规划器通常对应到一个线程，CActiveScheduler 类的静态方法通常都是针对当前线程中对象的操作。
在程序中使用活动对象时，首先应该创建一个活动规划器对象，并把它安装到当前线程，也就是把活动规划器和当前线程关联。 CActiveScheduler::Install()方法可以把活动规划器安装到当前线程， CActiveScheduler::Current() 方法可以获取和当前线程关联的活动规划器。如：

Add()方法可以把活动对象添加到活动规划器中，这样活动规划器就可以处理活动对象所提出的异步请求，当异步请求完成事件发生时调用活动对象的RunL()方法。
活动规划器的 Add() 方法把指定的活动对象添加到当前的活动规划器中。但是在某些时候可能需要删除在活动规划器中的活动对象：如果活动对象被销毁，那么同时活动对象就在活动规划器中被删除了，另外使用活动规划器的Deque()方法也可以把活动对象从活动规划器中删除。
在调用Add()方法之前必须确认活动规划器已经安装到当前线程，否则将发生E32USER-CBase 44 panic。Add()方法包括一个CActive型的参数， 这是一个指向活动对象的指针，在调用Add()方法时，这个指针不可以为 NULL,否则函数发生 E32USER-CBase 48 panic。另外与要注意的是，在使用Add()方法之前确认活动对象是否已经添加到活动规划器中，如果这个对象已经添加到活动规划器中那么将发生E32USER-CBase 41 panic。
CActiveScheduler::Start()方法启动一个在当前活动规划器控制下的的循环等待。而CActiveScheduler::Stop()则可以终止活动规划器的循环等待。活动规划器实际上是构建了一个事件处理的框架，它在循环中使用User::WaitForAnyRequest()等待活动对象的异步请求，当请求事件完成时，就调用一该请求事件相关的活动对象的RunL()方法。活动对象调用RunL()时把它放在TRAP下，这样即使RunL()函数发生Leave活动对象也有可以对它处理，执行一些必要的内存清理。当RunL()发生异常退出之后，首先进入活动对象的RunError()方法，这个方法是一个需方法，有一个默认实现，并返回一个整型的值，如果返回的整形值不是KEeeNone，那么活动规划器将调用自己的Error()方法。Error()方法也有一个默认的实现：发生一个E32USER-CBase 47 panic。

活动对象（Active Object）

CActive类是活动对象（Active Object）的核心类，所有的活动对象类应该从这个类继承。在CActive 中，封装了两个功能：一个是向异步服务提供者发出异步请求；另外一个是处理请完成事件。一个应用程序中可以包含若干个活动对象，并且是它们的都在活动规划器（active scheduler）的控制下运行。
活动对象应该包括一个和请求函数相关连的请求对象，请求函数是专门用于完成异步请求的，由于带有请求函数的对象提供了异步服务，所以在SDK的文档里又把他们叫做异步服务提供者（asynchronous service provider）。这里可以举一个简单的例子，RTimer中包括了一些请求函数，如After()、At()等。所以RTimer型的对象是一个异步服务提供者。所以在活动对象中，通常会有一个服务提供者成员，它的作用是提出一个异步请求，并异步完成他们的请求。
活动对象的 RunL() 方法用于处理活动对象的请求完成事件。活动对象类作为CActive类的派生类，它必须实现RunL()方法。如果有业务逻辑需要，RunL()可以发出另外一个新的异步请求。当请求结束事件发生时，这个函数被活动规划器调用，也就是说，在活动规划器的WaitForAnyRequest()函数结束以后RunL()函数被调用。WaitForAnyRequest()实际上是对User::WaitForAnyRequest()的调用。
在调用活动对象的RunL方法前，活动规划器需要确定，哪一个活动对象拥有最高优先权，然后标记该对象的请求作为请求完成事件。这个优先权是在活动对象构造的时候指定的。RunL运行在活动规划器所设定的TRAP中，如果RunL在执行过程中发生leave那么,那么活动规划器将调用RunError()方法。一旦调用了活动规划器的 Start方法，那么所有的用户代码将运行在活动规划器的某个活动对象的RunL()函数或RunError函数下。
活动对象 RunError() 方法用于处理请求结完成事件处理函数RunL() 的异常退出（Leave）。如果活动对象的RunL()函数发生Leave,那么活动规划器将调用活动对象的RunError方法。这样这个发生错误的活动对象就可以完成一些必要的内存清理。如果有派生类实现了这个方法，那么就应该对可能的 leave 做出处理，并返回KErrNone；如果返回了其他的错误码，那么CActiveScheduler类的Error()将被调用。
RunError() 方法的默认实现返回一个异常退出码，而一旦发生leave这个异常退出码是一个非KErrNone的值，这样可以认为：一般情况下，活动对象的RunL()方法如果发生leave，那么CActiveScheduler类的Error()将被调用。
注意：如果活动对象用于错误处理，那么在他的派生类中应该提供一个比较好的CActiveScheduler Error函数，以便处理那些错误。
活动对象的SetActive()方法用于向活动规划器提交一个异步请求。派生类应该在请求发出以后调用这个方法。活动对象也可以通过一定的方法来取消请求，但是这里需要说明的是，取消请求只是让请求提前完成。关于异步请求取消可以使用Cancel()方法。

请求状态（TRequestStatus）

服务提供者为了完成服务，需要有一个如何完成服务的信息。TRequestStatus 类的对象用于存放为服务提供者定制的请求完成状态。当线程提出请求时，例如RTimer 的After()请求，请求状态对象被作为参数传递到请求函数中。服务完成以后，服务提供者发送信号给服务请求对象的请求信号量并在请求对象中保存一个完成码，通常这个完成码的值是KErrNone或者是其他系统定义的错误码。TRequestStatus 类是密封类，不再被继承。

活动规划器和活动对象协同工作

这里的代码和附件中的例子一致，可以下载例子直接在VC6++中调试。活动规划器和活动对象的的协同工作过程如下。首先应该创建一个与当前线程相关的活动规划器：

接着创建一个活动对象，TmCount类是一个从CActive类派生的活动对象类。

然后可以从NewLC()方法中看到活动对象构造的具体细节：

在这个默认的构造函数中，还调用了默认的C++构造函数，这个比较关键，因为正是在这个构造函数中，把活动对象添加到了活动对象，在这个；函数中，还可以定义活动对象的优先权限：

这样，活动对象构造完成。接着，程序调用活动对象的请求函数。

在活动对象的请求函数中：

异步服务提供者处理请求，当请求处理完成以后，它生成一个事件。活动规划器不断的检查是否有请求完成（是否有请求完成事件发生），如果有请求完成，那么调用与该请求相关联的活动对象的RunL()方法：

在这个方法中又提出了一次异步请求，并使计数器值增加。如果条件符合则可以不再让活动对象提出异步请求，这是一个修改后的RunL()：

如果RunL()在运行过程中发生错误，则RunError()被调用，以下是RunEror（）方法：

         人类眼睛的色觉，具有特殊的特性，早在上世纪初，Young（1809）和Helmholtz（1824）就提出了视觉的三原色学说，即：视网膜存在三种视锥细胞，分别含有对红、绿、蓝三种光线敏感的视色素，当一定波长的光线作用于视网膜时，以一定的比例使三种视锥细胞分别产生不同程度的兴奋，这样的信息传至中枢，就产生某一种颜色的感觉。

       70年代以来，由于实验技术的进步，关于视网膜中有三种对不同波长光线特别敏感的视锥细胞的假说，已经被许多出色的实验所证实。 例如：①有人用不超过单个视锥直径的细小单色光束，逐个检查并绘制在体（最初实验是在金鱼和蝾螈等动物进行，以后是人）视锥细胞的光谱吸收曲线，发现所有绘制出来的曲线不外三种类型，分别代表了三类光谱吸收特性不同的视锥细胞，一类的吸收峰值在420nm处，一类在534nm处，一类在564nm处，差不多正好相当于蓝、绿、红三色光的波长。与上述视觉三原色学说的假设相符。②用微电极记录单个视锥细胞感受器电位的方法，也得到了类似的结果，即不同单色光所引起的不同视锥细胞的超极化型感受器电位的大小也不同，峰值出现的情况符合于三原色学说。