设备仿真程序

[image]

设备仿真程序
设备仿真程序

设备仿真程序模拟基于 Windows CE 或 Windows Mobile 的硬件平台的行为。

本节内容

关于设备仿真程序

描述设备仿真程序的更多重要功能。

设备仿真程序的系统要求

列出对系统内存、处理器类型、可用磁盘空间和要求的 ActiveSync 版本的要求和建议。

设备仿真程序管理器

概述提供物理底座的逻辑功能的工具的用法。

保存状态的文件

说明如何使用此功能保存仿真程序图像的完整状态。

键盘

提供有关物理键盘和仿真程序收到的按键之间关系的信息。

外观

概述外观的概念和如何自定义外观。

连接问题疑难解答

介绍各种连接方案和表现以及更正的步骤。

配置和使用设备仿真程序

介绍一系列常见仿真程序任务以及执行这些任务的步骤。

设备仿真程序参考

包含有关命令行启动、用于自定义外观的 XML 架构、组合键以及用户界面组件的参考材料。


设备仿真程序的新增功能

[image]

设备仿真程序
设备仿真程序的新增功能
请参见

设备仿真程序中包含下列新增或扩展功能。

注意 注意：

默认情况下，Device Emulator 3.0 版会覆盖以前的安装，并且安装到 \Program Files\Microsoft Device Emulator\1.0 中。

Device Emulator 3.0 中的新增功能

设备仿真程序管理器中的“我的仿真程序”和“所有设备仿真程序”

保存在“%USERPROFILE%\My Documents\My Device Emulators”（在 Windows Vista 中为“%USERPROFILE%\Documents\My Device Emulators”）中的设备仿真程序配置文件显示在设备仿真程序管理器的“我的设备仿真程序”节点中。保存在“\Documents and Settings\All Users\Documents\All Device Emulators”（在 Windows Vista 中为“\Users\Public\Documents \All Device Emulators”）中的设备仿真程序配置文件显示在设备仿真程序管理器的“所有设备仿真程序”节点中。使用此功能，可以在数据存储外部保存和自定义一组仿真程序。有关更多信息，请参见设备仿真程序配置文件和设备仿真程序管理器。

另存和重新配置

可以将设备仿真程序设置保存到设备仿真程序配置 XML 文件，并对这些设置进行重新配置。有关更多信息，请参见设备仿真程序配置文件。

自动化接口

自动化接口是 COM 接口，它们公开了设备仿真程序管理器中的功能。通过在应用程序中使用此接口，可以以编程方式控制设备仿真程序管理器。有关更多信息，请参见设备仿真器管理器的自动化接口和设备仿真程序管理器。

Device Emulator 2.0 中的新增功能

性能提升

设备仿真程序的性能已获得显著改进。许多操作的执行时间缩短了一半。

通知 LED、振动、背光和屏幕对比度的模拟

设备仿真程序现在可模拟通知 LED、振动、背光和屏幕对比度硬件。例如，设备仿真程序窗口会通过闪烁来模拟振动，而屏幕会在调整对比度时变暗或变亮。

注意 注意：

操作系统映像必须支持设备仿真程序的硬件。通常，Windows Mobile 6 以及更高版本的映像支持这些新增功能。

话筒、耳机和车载的模拟

此功能模拟物理话筒、耳机或车载的存在。有关更多信息，请参见如何：模拟耳机、话筒或车载的存在。

注意 注意：

操作系统映像必须支持设备仿真程序的硬件。通常，Windows Mobile 6 以及更高版本的映像支持这些新增功能。

电池模拟

此功能模拟电池的存在。有关更多信息，请参见如何：在设备仿真程序上调整电池设置。

注意 注意：

操作系统映像必须支持设备仿真程序的硬件。通常，Windows Mobile 6 以及更高版本的映像支持这些新增功能。

请参见

概念

关于设备仿真程序
设备仿真程序管理器


关于设备仿真程序

[image]

设备仿真程序
关于设备仿真程序
请参见

Microsoft Device Emulator 3.0 版是一个桌面应用程序，它可以用来模拟基于 Windows CE 或 Windows Mobile 的硬件平台的行为。使用 Device Emulator 时，无需物理设备即可运行、测试和调试运行时映像。默认情况下，Device Emulator 3.0 版会覆盖以前的安装，并且安装到 驱动器:\Program Files\Microsoft Device Emulator\1.0 下。

注意 注意：

设备仿真程序仅模拟硬件。若要运行设备仿真程序，必须指定一个为设备仿真程序硬件设计的操作系统映像文件。映像文件可以单独下载，或是随 Visual Studio 或 Windows Mobile SDK 一起安装。

功能

设备仿真程序的很多功能与其早期版本相比有很大的改进。设备仿真程序：

  • 运行针对 ARM 处理器而不是 x86 处理器编译的代码。在大多数情况下，可以在仿真程序和设备上运行相同的二进制代码。

  • 支持与 ActiveSync 的同步。可以将仿真程序与 ActiveSync 全面结合使用。使用此功能可以调试正在同步的应用程序，或者使用仿真程序内的实际同步数据。

  • 支持更多的开发环境，例如 Visual Studio 2008、Visual Studio 2005、Visual Studio .NET 2003 和 eMbedded Visual C++ 4.0 (Service Pack 4)。这些开发环境都使用了 ActiveSync。

  • 支持 GAPI。可以在此仿真程序上编写并调试游戏。

适应性

可以像配置一个真正的硬件平台一样，对此虚拟硬件平台进行配置。可以指定屏幕分辨率和方向、内存大小、外观设计和其他属性。此外，可以为模拟的硬件按钮和软键编写事件处理代码。其主要限制在于：无法模拟性能。因为仿真程序的性能在很大程度上取决于开发计算机的处理器速度和可用的系统内存量，以及不会影响不同物理设备性能的其他因素。有关更多信息，请参见配置和使用设备仿真程序。

保存状态

可以运行设备仿真程序的一个或多个实例，也可以保存任何实例的状态，以供在后面的开发中使用。有关更多信息，请参见保存状态的文件。

外观

可以应用现有的自定义外观或编写自己的外观文件。有关更多信息，请参见 外观。

启动

设备仿真程序的启动方式取决于您的安装。Device Emulator 可以从网站下载，也可以从 Visual Studio 安装中获取。有关更多信息，请参见如何：启动设备仿真程序。

请参见

概念

设备仿真程序


设备仿真程序的系统要求

[image]

设备仿真程序
设备仿真程序的系统要求
请参见

只有开发计算机满足下表中的要求时，才能运行配置为使用 64 MB 内存的设备仿真程序的一个实例。

项 | 最低要求 | 建议
系统内存 | 256 MB | 512
处理器 | 600 MHz Pentium | 1.8 GHz Pentium
可用磁盘空间 | 50 MB | 50 MB
Microsoft ActiveSync 或 Window Mobile 设备中心 | 4.0 或更高版本 | 4.0 或更高版本

其他每个实例都需要额外的系统内存，该内存总共是：

  • 32 MB；

  • 配置实例所使用的内存量。

例如，配置使用 64 MB 内存的第二个实例需要 32 + 64 MB 内存；换言之，开发计算机中需要 96 MB 的系统内存。

请参见

概念

设备仿真程序


设备仿真程序管理器

[image]

设备仿真程序
设备仿真程序管理器
请参见

使用设备仿真程序管理器 (DEM) 启动、连接和管理开发计算机上的设备仿真程序。使用设备仿真程序管理器的全部任务可以分为以下几个类别：

  • 启动 DEM

  • 组织 DEM 中显示的仿真程序

  • 从 DEM 执行对设备仿真程序的操作

  • 以编程方式控制 DEM

  • 支持 ActiveSync 或 Windows Mobile 设备中心通信

  • 其他功能

下面的信息描述 DEM 提供的功能。

启动 DEM

对于不同的安装，设备仿真程序管理器的启动方式不尽相同。有关更多信息，请参见如何：启动设备仿真程序管理器。

DEM 中显示的仿真程序的组织

设备仿真程序管理器显示为一个窗口，该窗口中显示仿真程序的树视图。该树视图有三个根节点：“数据存储”、“我的设备仿真程序”和“其他”。下表描述每个根节点下的仿真程序。

节点

说明

数据存储

列出数据存储中注册的所有设备仿真程序。通常，这些仿真程序由 Visual Studio、Windows Mobile SDK 或 Windows CE SDK 安装在开发计算机的数据存储中。

注意 注意：

在独立安装中，不存在保存仿真程序的映像和信息的数据存储。典型的情况是将设备仿真程序下载到未安装 Visual Studio 的开发计算机上。

我的设备仿真程序

列出“%USERPROFILE%\My Documents\My Device Emulators”（在 Windows Vista 中为“%USERPROFILE%\Documents\My Device Emulators”）文件夹中存储的设备仿真程序配置文件 (.decfg)。通过执行“另存为”仿真程序操作，或手动创作仿真程序配置 .decfg 文件，可以创建仿真程序配置。

所有设备仿真程序

列出“\Documents and Settings\All Users\Documents\All Device Emulators”（在 Windows Vista 中为“\Users\Public\Documents\All Device Emulators”）文件夹中存储的设备仿真程序配置文件 (.decfg)。通过执行“另存为”仿真程序操作，或手动创作仿真程序配置 .decfg 文件，可以创建仿真程序配置。

其他

列出正在运行但不在“数据存储”、“我的设备仿真程序”或“所有设备仿真程序”节点中的仿真程序。每个正在运行的仿真程序都有一个唯一的虚拟机标识符 (VMID)。如果 DEM 无法为一个仿真程序在“数据存储”、“我的设备仿真程序”和“所有设备仿真程序”节点中找到匹配的 VMID，则会此列出该仿真程序。

从 DEM 执行对设备仿真程序的操作

从 DEM 树视图中选择设备仿真程序之后，从“操作”菜单上，或右击仿真程序，都可以对设备仿真程序执行操作。下表描述每个操作。

操作

说明

连接

启动仿真程序，并将仿真程序连接到桌面计算机。

插入底座

将仿真程序插入底座。必须先连接到仿真程序，然后才能将其插入底座。

注意 注意：

必须安装用于检测和响应已插入底座的设备的软件，如 ActiveSync 或 Windows Mobile 设备中心。

移除底座

移除仿真程序底座。

关闭

关闭仿真程序。

注意 注意：

仿真程序在关闭前不会提示您保存状态。

重置

重置（软）仿真程序。

清除保存状态

清除仿真程序的已保存状态。仿真程序下次将从操作系统的映像启动。有关更多信息，请参见保存状态的文件。

置于顶层

使仿真程序在被其他窗口覆盖时可见。

重新配置

提示您选择一个设备仿真程序配置文件 (.decfg)，将仿真程序重新配置为该文件中的设置。有关更多信息，请参见设备仿真程序配置文件。

另存为

将仿真程序的配置保存为设备仿真程序配置文件 (.decfg)。有关更多信息，请参见设备仿真程序配置文件

以编程方式控制设备仿真程序管理器

自动化接口提供对设备仿真程序管理器的功能的编程访问。设备仿真程序管理器公开一个 COM 接口，该接口可用在应用程序和脚本语言中。有关更多信息，请参见设备仿真器管理器的自动化接口。

对 ActiveSync 通信的支持

通过提供与物理设备底座相同的逻辑功能，DEM 实现了通过 ActiveSync 与设备仿真程序进行通信。当设备插入底座时，设备可以使用 ActiveSync 同步电子邮件内容、日历和应用程序安装等。仿真程序本身没有等效的功能，并且无法使用 ActiveSync，除非将其插入底座。仿真程序、DEM 和 ActiveSync 组合在一起，就相当于拥有了一个物理设备和一个底座。一种常见情况是，启动设备仿真程序，使用 DEM 将其插入底座，然后建立设备仿真程序与 ActiveSync 的合作关系。有关更多信息，请参见如何：将设备仿真程序插入底座和移除底座。

注意 注意：

在 Windows Vista 中，Windows Mobile 设备中心取代了 ActiveSync。

其他功能

使用 DEM 窗口，还可以执行下列任务：

  • 通过在“文件”菜单上单击“打开”，可以检索以前保存的状态映像 (.dess) 或设备仿真程序配置 (.decfg)。

  • 无论所有仿真程序是处于运行、关闭还是插入底座状态，都可以通过单击“刷新”获取所有仿真程序的状态。

  • 当状态保存文件使用网络连接、串行端口和文件夹共享时，可以禁用提示启用这些功能的信息。若要禁用提示，请在“文件”菜单上单击“无安全提示”。

    安全说明 安全说明：

    只要使用文件夹共享功能，就会带来潜在的安全风险。禁用这些提示时，请务必谨慎。

请参见

概念

设备仿真程序


保存状态的文件

[image]

设备仿真程序
保存状态的文件
请参见

通过单击仿真程序“文件”菜单上的“保存状态”，可以随时保存设备仿真程序的状态。此外，系统还将会提示您在关闭仿真程序时随时保存状态。如果选择“保存状态”选项，仿真程序会创建一个扩展名为 .dess（Device Emulator Saved State，设备仿真程序保存状态）的文件。此文件不仅包含操作系统映像，还包含内存状态、配置、共享文件夹等。换言之，.dess 文件表示仿真程序在模拟挂起到 RAM 操作时所具有的完整状态。默认情况下，用户特定的保存状态文件位于 驱动器:\Documents and Settings\用户名\Application Data\Microsoft\Device Emulator 下。全局保存状态文件位于 驱动器:\Documents and Settings\All Users\Application Data\Microsoft\Device Emulator 下。

注意 注意：

默认情况下，保存状态映像是基于每个用户创建的。若要创建全局保存状态映像，请从命令行使用 /g 开关启动仿真程序。有关更多信息，请参见设备仿真程序命令行参考。如果基础操作系统映像已更改（可能缘于更新），则设备仿真程序会提示您，从操作系统映像冷重启动或加载保存状态映像。如果出现此提示，则说明自上次启动保存状态映像以来，操作系统映像已进行过更改。

由于 .dess 扩展名是在安装时注册的，因此，双击一个 .dess 文件会使用该文件中保存的状态启动设备仿真程序。Visual Studio 支持每个设备仿真程序具有一个 .dess 文件。

安全说明 安全说明：

使用来自不受信任源的保存状态文件会导致安全风险。

保存状态文件与操作系统映像文件

映像文件是复制到设备闪存上的操作系统副本。默认情况下，映像文件位于 驱动器:\Program Files\Microsoft Visual Studio 9.0\SmartDevices\Emulators\Images 下，这些文件的扩展名为 .bin。与从 .dess 文件启动相比，仿真程序从映像文件启动需要更长的时间，这是因为仿真程序必须通过映像文件模拟操作系统的所有冷启动代码。相反，.dess 文件包含设备休眠时电池会维持的所有状态数据。因此，若要继续操作，仿真程序只需将 .dess 文件还原到模拟的 RAM 和外围设备，然后从中断的位置继续执行。为此，Visual Studio 为部分仿真程序提供了默认 .dess 文件。这些文件存储在 驱动器:\Documents and Settings\All Users\Application Data\Microsoft\Device Emulator\ 下。默认的 .dess 文件表示设备完成冷启动时的状态。如果仿真程序具有默认 .dess 文件，以默认设置启动时，则会加载该文件，而不是映像文件。

在用户界面中，状态保存选项如下所示：

提示 | 操作
关闭但不保存 | 关闭设备仿真程序，但不保存状态。 这是默认设置。
保存 | 将当前状态保存为仿真程序的当前虚拟机标识符 (VMID)。 在 Visual Studio 中，如果数据存储已将此 VMID 的标志设置为“受保护”，则此选项为禁用状态。

请参见

概念

如何：启动设备仿真程序
如何：启动设备仿真程序管理器
如何：还原仿真程序的 OS 映像
设备仿真程序


设备仿真程序配置文件

[image]

设备仿真程序
设备仿真程序配置文件
请参见

设备仿真程序配置 (.decfg) 文件是 XML 文件，这些文件包含用于配置设备仿真程序实例的设置。可以在 .decfg 文件中配置设置，如操作系统映像、外观、LCD 屏幕分辨率和网络。有关完整的设置列表，请参见设备仿真程序配置 XML 架构参考。

从 DECFG 文件启动设备仿真程序

使用“设备仿真程序管理器”启动“设备仿真程序配置”仿真程序。保存在“%USERPROFILE%\My Documents\My Device Emulators”（在 Windows Vista 中为“%USERPROFILE%\Documents\My Device Emulators”）中的所有 .decfg 文件显示在“设备仿真程序管理器”的“我的设备仿真程序”节点中。保存在“\Documents and Settings\All Users\Documents\All Device Emulators”（在 Windows Vista 中为“\Users\Public\Documents \All Device Emulators”）中的所有 .decfg 文件显示在“设备仿真程序管理器”的“所有设备仿真程序”节点中。就像任何“数据存储”仿真程序一样，您可以对“设备仿真程序配置”仿真程序进行连接、断开连接和插入底座操作。

可以使用 .decfg 文件和“设备仿真程序管理器”管理自定义仿真程序配置，并避免使用较长的命令行参数。有关更多信息，请参见设备仿真程序管理器。

您还可以从命令提示符处启动“设备仿真程序配置”仿真程序。有关更多信息，请参见设备仿真程序命令行参考。

创作 DECFG 文件

可以从头创作 .decfg 文件，也可以从现有 .decfg 文件进行创作。若要从现有的仿真程序创建 .decfg 文件，请右击“设备仿真程序管理器”中的一个正在运行的仿真程序，再单击“另存为”。然后，使用 XML 编辑器修改该 .decfg 文件。有关更多信息，请参见设备仿真程序配置 XML 架构参考。

请参见

概念

设备仿真程序配置 XML 架构参考
设备仿真程序管理器


键盘

[image]

设备仿真程序
键盘
请参见

以下注意事项适用于开发计算机的键盘和仿真程序感应到的击键之间的关系。

映射特性

开发计算机的键盘和 Smartphone 或 Pocket PC 仿真程序小键盘之间的映射不一定匹配。桌面击键和单击仿真小键盘之间的映射由外观文件提供。例如，当您单击仿真 Smartphone 小键盘上的 * 时，仿真程序接收到 F8 击键。因此，按开发计算机键盘上 F8 的行为就像单击仿真小键盘一样。另一方面，如果您按开发计算机键盘上的 Shift+8，Smartphone 仿真程序 OS 实际从它认为是小键盘的地方接收 Shift+8，并且忽略击键。

请参见

概念

设备仿真程序


外观

[image]

设备仿真程序
外观
请参见

仿真程序外观用于控制设备仿真程序的图形用户界面 (GUI) 的外观和功能。使用仿真程序外观，可以使仿真程序具有特定硬件平台的外观和行为。

无论使用外观与否，都可以选择运行设备仿真程序。如果使用外观运行仿真程序，该外观会影响仿真程序窗口的外观。仿真程序外观会重写设备仿真程序的视频显示设置。

自定义外观

您可以用所选的外观创建仿真程序外观，还可以创建按下后外观发生变化的按钮。有关更多信息，请参见 如何：自定义仿真程序的外观。

技术

仿真程序外观最多包含三个位图 (BMP) 或可移植网络图形 (PNG) 文件，以及一个包含可扩展标记语言 (XML) 的外观定义文件 (.xml)。外观定义文件和关联的 BMP 或 PNG 文件必须位于同一个目录中。

第一个 BMP 或 PNG 文件称作“常规”图形文件，可用于显示仿真程序外观的默认外观。常规图形文件是仿真程序外观必需的唯一文件。第二个可选的 BMP 或 PNG 文件称作“下凹”图形文件，可用于显示按下所有按钮时仿真程序外观的外观。第三个可选的 BMP 或 PNG 文件称作“映射”文件，可用于显示仿真程序外观中每个按钮的颜色代码。在映射文件中，每个按钮的颜色代码用完全覆盖该按钮的单颜色区域来表示。仿真程序外观用户看不到在映射文件中用作代码的颜色。

.xml 文件用于描述外观的工作方式，以及查找 BMP 或 PNG 文件的位置。此外，.xml 文件还可以根据映射文件中所示的颜色代码定义按钮的操作。有关更多信息，请参见设备仿真程序外观 XML 架构参考。

请参见

概念

“仿真程序属性”对话框 ->“显示”
设备仿真程序外观 XML 架构参考
设备仿真程序


连接问题疑难解答

[image]

设备仿真程序
连接问题疑难解答
请参见

下面的信息旨在帮助您解决在尝试将设备仿真程序连接到开发计算机时可能遇到的问题。

连接到设备仿真程序

使用 Visual Studio 提供的用于连接到设备仿真程序的 DMA 传输。此传输几乎可以消除开发计算机与仿真程序之间的所有连接问题。

重要说明 重要说明：

只有当您有某些重要的特定原因时才可使用 TCP/IP 传输。若要解决仿真程序使用 TCP/IP 而引发的问题，请查看以下步骤。有关更多信息，请参见“Mobile Developer Center”（移动开发人员中心）。

在无网络连接的情况下连接到设备仿真程序

要在没有网络连接的情况下将开发计算机通过 TCP/IP 连接到设备仿真程序，必须：

  • 安装 Microsoft 环回适配器。有关更多信息，请参见安装 Microsoft 环回适配器。

  • 将环回适配器绑定到 NE2000 卡。可以从“仿真程序属性”对话框的“网络”选项卡中完成此操作。打开此对话框的方式取决于具体的安装情况。有关更多信息，请参见如何：更改属性设置。

使用 ActiveSync 连接到设备仿真程序

使用 Microsoft ActiveSync 可以连接到设备仿真程序，步骤如下：

  1. 启动“设备仿真程序管理器”。

    有关更多信息，请参见如何：启动设备仿真程序管理器。

  2. 连接到所需的仿真程序。

  3. 使用“设备仿真程序管理器”，将所选的仿真程序插入底座。

  4. 在 ActiveSync 中打开“进行连接”对话框，然后按照说明建立合作关系。

只要从 Visual Studio 中以 Pocket PC 设备为目标，就是通过 ActiveSync 以仿真程序为目标。如果关闭设备仿真程序管理器或关闭仿真程序，则 ActiveSync 连接也将关闭。

生成新的 MAC 地址

可以为仿真程序建立新的 MAC 地址。该过程有时可帮助对网络问题进行疑难解答。

  • 在注册表中，删除 HKEY_CURRENT_USER\Software\Microsoft\Device Emulator\MAC Addresses 下面的 GUID 项。

    仿真程序将为其自身生成一个新的 MAC 地址。

识别仿真程序的 IP 地址

如何发现仿真程序使用的 IP 地址取决于您使用的仿真程序的版本。例如，适用于 Pocket PC 的步骤与适用于 Smartphone 的步骤不同。

  • 在 Pocket PC 仿真程序“开始”菜单上，单击“设置”，单击“连接”，单击“网卡”，然后单击相应的适配器（例如“NE2000 兼容以太网驱动程序”）。

  • 在 Smartphone 仿真程序中，运行一个小应用程序以显示 IP 地址。有关更多信息，请参见 如何：显示 Smartphone 仿真程序的 IP 地址。

无法打开虚拟交换机驱动程序

如果试图使用仿真的 NE2000 或 CS8900 卡将设备仿真程序连接到网络，则需要虚拟交换机驱动程序。（您可以从 Mobile Developer Center（移动开发人员中心）下载驱动程序。）

打开驱动程序时发生错误的原因有多种：

  • 缺少驱动程序。

  • 开发计算机上的网卡未安装驱动程序。

  • 安装驱动程序的过程存在问题。

  • 驱动程序处于禁用状态。

  • 开发计算机上没有网卡。

使用下列步骤诊断确切原因。

诊断故障的确切原因

  1. 查看“仿真程序属性”对话框的“网络”选项卡。

    如果 NE2000 和/或 CS8900 卡已启用，请确认它们所绑定到的网卡存在且已连接。（要打开“仿真程序属性”对话框，请在仿真程序的“文件”菜单上单击“配置”。）

  2. 查看适配器的网络属性，验证“虚拟机网络服务”项是否存在、启用并且具有正确的版本（2.6.465.224 或更高版本）。

  3. 如果这些步骤未能解决问题，请重新安装驱动程序。

连接到网络

设备仿真程序本身没有网络连接。

将仿真程序连接到网络

  • 将仿真程序插入底座。

    有关更多信息，请参见如何：将设备仿真程序插入底座和移除底座。

    - 或 -

  • 安装虚拟交换机驱动程序。

    您可以从“Mobile Developer Center”（移动开发人员中心）下载驱动程序。

请参见

概念

设备仿真程序


配置和使用设备仿真程序

[image]

设备仿真程序
配置和使用设备仿真程序

设备仿真程序设计为具有极高的可配置性。下面的主题介绍完成部分更常见任务的步骤。

本节内容

如何：更改属性设置

阐释如何显示“仿真程序属性”对话框。

如何：还原仿真程序的 OS 映像

描述如何还原仿真程序操作系统映像。

如何：生成保存状态文件

演示如何使用 Imagegen 工具生成设备仿真程序的已保存状态文件。

如何：启动设备仿真程序

描述启动设备仿真程序的各种方式。

如何：启动设备仿真程序管理器

描述启动设备仿真程序管理器的各种方式。

如何：将运行时映像下载到仿真程序

阐释如何将运行时映像下载到设备仿真程序。

如何：以 Visual Studio 中支持 KITL 的运行时映像为目标

解释如何将设备映像与已安装的 SDK 相关联。

如何：模拟热启动或冷启动

演示如何模拟热重启动和冷重启动。

如何：将 Platform Builder 附加到运行的仿真程序

阐释如何附加到正在运行的仿真程序。

如何：关闭设备仿真程序

解释如何从仿真程序窗口或设备仿真程序管理器中关闭设备仿真程序。

如何：配置远程工具通信

演示如何配置远程工具以便与设备仿真程序建立连接。

如何：更改以太网设置

阐释更改以太网设置的各种方式。

如何：将目录映射到设备仿真程序

演示如何将目录映射到设备仿真程序。

如何：从设备仿真程序中移除映射的目录

解释如何从设备仿真程序中移除映射的目录。

如何：使用文件夹共享模拟存储卡

阐释如何激活和停止文件夹共享。

如何：将文件移入和移出设备仿真程序

演示如何使用共享文件夹将文件移入或移出仿真程序。

如何：将设备仿真程序插入底座和移除底座

解释如何将设备仿真程序插入底座和移除底座。

如何：调整设备仿真程序中 RAM 的大小

演示调整 RAM 大小的各种方式。

如何：指定共享文件夹

演示如何指定共享文件夹。

如何：指定主机键

解释如何指定主机键。

如何：指定外观文件

演示如何指定外观文件。

如何：更改外观方向

阐释如何更改外观的方向。

如何：启用仅主机网络

解释如何启用仅主机网络。

如何：映射串行端口

演示如何映射串行端口。

如何：启用工具提示

解释如何启用工具提示。

如何：自定义仿真程序的外观

演示如何开发自定义外观以及如何使用该外观。

如何：访问 Smartphone 仿真程序文件系统

阐释如何访问 Smartphone 仿真程序文件系统。

如何：显示 Smartphone 仿真程序的 IP 地址

演示如何以编程方式发现 Smartphone 仿真程序的 IP 地址。

如何：模拟耳机、话筒或车载的存在

解释如何模拟硬件的存在。

如何：在设备仿真程序上调整电池设置

解释如何模拟电池或交流电源。

如何：在设备仿真程序上启用 TCP/IP 网络

描述如何在不使用 ActiveSync 插入底座功能的情况下从设备仿真程序获取 TCP/IP 网络（用于 Internet 连接）。

相关章节

设备仿真程序

提供指向解释设备仿真程序的各个主题的链接。


如何：更改属性设置

[image]

设备仿真程序
如何：更改属性设置
请参见

通过“仿真程序属性”选项卡式对话框更改设备仿真程序属性设置。如果选项灰显，则该选项在当前环境下不可用。

如何显示此选项卡式对话框取决于您的安装。

从“设备仿真程序文件”菜单中显示该对话框

  1. 启动设备仿真程序。

    设备仿真程序的启动方式取决于您的安装。有关启动仿真程序的更多信息，请参见 如何：启动设备仿真程序。

  2. 在设备仿真程序的“文件”菜单上单击“配置”。

    随即打开“仿真程序属性”选项卡式对话框。

在 Platform Builder 的 IDE 中显示该对话框

  1. 在 Platform Builder 的“目标”菜单上单击“连接选项”。

  2. 在“目标设备连接选项”对话框中单击“内核服务映射”。

  3. 在“下载”框中，选择“设备仿真程序”，然后单击“设置”。

  4. 随即打开“仿真程序属性”选项卡式对话框。

在 Visual Studio IDE 中显示该对话框

  1. 在 Visual Studio 的“工具”菜单上单击“选项”。

  2. 在“选项”对话框中，展开“设备工具”，然后单击“设备”。

  3. 从“设备”框中选择一个仿真程序，然后单击“属性”。

  4. 在“<Projectname> 仿真程序属性”对话框中单击“仿真程序选项”。

    随即打开“仿真程序属性”选项卡式对话框。

请参见

概念

设备仿真程序用户界面参考
配置和使用设备仿真程序


如何：还原仿真程序的 OS 映像

[image]

设备仿真程序
如何：还原仿真程序的 OS 映像
请参见

若要将 OS 映像还原到仿真程序，请使用设备仿真程序管理器。

有关更多信息，请参见如何：启动设备仿真程序管理器。

安全说明 安全说明：

使用来自不受信任来源的保存状态文件会导致安全风险。

还原仿真程序 OS 映像

  1. 在“设备仿真程序管理器”的“文件”菜单上单击“还原映像”。

  2. 在“选择要还原的映像”对话框中，选择要还原的映像，然后单击“打开”。

请参见

概念

保存状态的文件
如何：将运行时映像下载到仿真程序
设备仿真程序


如何：生成保存状态文件

[image]

设备仿真程序
如何：生成保存状态文件
请参见

Imagegen 工具（包含在 Visual Studio 中）生成设备仿真程序的保存状态文件并执行某些其他功能，如清除全局保存状态缓存。

注意 注意：

对于在以下说明中使用的某些 Visual Studio 用户界面元素，您的计算机可能会显示不同的名称或位置。这些元素取决于您所使用的 Visual Studio 版本和您所使用的设置。有关更多信息，请参见 Visual Studio 设置。

启动 Imagegen.exe

  1. 打开控制台窗口。

  2. 定位到 Imagegen.exe，该文件的默认安装位置为 驱动器:\Program Files\Microsoft Device Emulator\1.0。

  3. 使用您选择的选项来运行该文件。

    有关命令行选项，请参见 Imagegen 命令行参考。

请参见

概念

保存状态的文件
配置和使用设备仿真程序


如何：启动设备仿真程序

[image]

设备仿真程序
如何：启动设备仿真程序
请参见

您可以通过若干不同方式启动设备仿真程序，具体取决于您的安装情况和个人首选项。

在 Visual Studio 中，在“工具”菜单上单击“开始执行”（或“开始执行(不调试)”），打开“部署”对话框，您可在此选择仿真程序，所选仿真程序将自动启动。

启动设备仿真程序

从命令行启动设备仿真程序

  1. 打开控制台窗口。

  2. 定位到 DeviceEmulator.exe，该文件默认安装在 \Program Files\Microsoft Device Emulator\1.0 目录下。

  3. 使用选择的选项运行该文件。

    有关命令行选项，请参见 设备仿真程序命令行参考。

从设备仿真程序管理器启动设备仿真程序

  1. 打开设备仿真程序管理器。

    此过程根据具体安装情况而定。独立安装设备仿真程序时要求先启动设备仿真程序，然后才能启动设备仿真程序管理器。有关更多信息，请参见如何：启动设备仿真程序管理器。

  2. 在“设备仿真程序管理器”窗口中右击要启动的仿真程序。

  3. 在快捷菜单上单击“连接”。

从 Platform Builder 启动设备仿真程序

  • 请参见 如何：将运行时映像下载到仿真程序。

从 Visual Studio IDE 启动设备仿真程序

  1. 在 Visual Studio 的“工具”菜单上，单击“连接到设备”。

  2. 在“连接到设备”对话框中，从“设备”框中选择一个仿真程序，然后单击“连接”。

    - 或 -

  3. 在 Visual Studio 的“工具”菜单上，单击“设备仿真程序管理器”。

  4. 在“设备仿真程序管理器”窗口中右击要启动的仿真程序。

  5. 在快捷菜单上单击“连接”。

请参见

概念

设备仿真程序


如何：启动设备仿真程序管理器

[image]

设备仿真程序
如何：启动设备仿真程序管理器
请参见

设备仿真程序管理器 (DEM) 提供了一个用户界面，用于在开发计算机上启动、连接和管理设备仿真程序实例。它提供了与物理设备底座相同的逻辑功能。有关更多信息，请参见设备仿真程序管理器。

当单击 DEM“文件”菜单上的“退出”时，即断开了插入底座的任何仿真程序映像。如果您只想从屏幕中移除 DEM 窗口，请关闭其窗口。DEM 会继续在后台运行，并且可从通知区域访问。

注意 注意：

对于在以下说明中使用的某些 Visual Studio 用户界面元素，您的计算机可能会显示不同的名称或位置。这些元素取决于您所使用的 Visual Studio 版本和您所使用的设置。有关更多信息，请参见 Visual Studio 设置。

在有数据存储的情况下启动

如果开发计算机有一个数据存储，该数据存储在某个时刻（例如，安装 Visual Studio 2008 时）保存了仿真程序映像，则可以使用下列任一方式打开 DEM。

从 Visual Studio 启动设备仿真程序管理器

  • 在“工具”菜单上单击“设备仿真程序管理器”。

从 Windows 资源管理器启动设备仿真程序管理器

  1. 定位到 Program Files\Microsoft Device Emulator\1.0。

  2. 打开 dvcemumanager.exe。

从命令行启动设备仿真程序管理器

  1. 定位到 Program Files\Microsoft Device Emulator\1.0。

  2. 键入 dvcemumanager。

在没有数据存储的情况下启动

如果开发计算机没有在适当位置（例如，设备仿真程序和 DEM 的独立安装中）包含数据存储，则必须先启动设备仿真程序的一个实例，然后才能打开 DEM。

在没有数据存储的情况下启动设备仿真程序管理器

  1. 启动设备仿真程序的实例。

    有关更多信息，请参见如何：启动设备仿真程序。

  2. 使用前面列出的在有数据存储的情况下进行启动的任一方法，启动设备仿真程序管理器。

  3. 在设备仿真程序管理器的“操作”菜单上，单击“刷新”。

请参见

概念

设备仿真程序


如何：将运行时映像下载到仿真程序

[image]

设备仿真程序
如何：将运行时映像下载到仿真程序
请参见

可以使用 Platform Builder、Visual Studio 或命令行将运行时 OS 映像下载到设备仿真程序。有关从命令行启动设备仿真程序的更多信息，请参见 如何：启动设备仿真程序。

安全说明 安全说明：

使用来自不受信任来源的保存状态文件会导致安全风险。

使用 Visual Studio 将运行时图像下载到设备仿真程序

  1. 在 Visual Studio 的“工具”菜单上，单击“连接到设备”。

  2. 在“连接到设备”对话框中，选择所需的 OS 映像，然后单击“连接”。

使用 Platform Builder 将运行时图像下载到设备仿真程序

  1. 在 Platform Builder 的“目标”菜单上单击“连接选项”。

  2. 在左窗格中，选择“内核服务映射”。

  3. 在“下载”框中单击“设备仿真程序”。

  4. 单击“设置”。

  5. 在“仿真程序属性”对话框中，修改设备仿真程序的设置，然后单击“确定”。

  6. 在“传输”框中，选择“以太网”。

  7. 单击“核心服务设置”。在“KITL 设置”中，选择所需的以下任何设置：

    • 启用 KITL

    • 启用对桌面文件的访问

    • 软件重置时清除内存

  8. 单击“应用”。

  9. 在“目标”菜单上单击“附加设备”。

    本步骤假定您的工作区中已打开一个映像。

请参见

概念

“仿真程序属性”对话框 ->“显示”
“仿真程序属性”对话框 ->“常规”
“仿真程序属性”对话框 ->“网络”
“仿真程序属性”对话框 ->“外围设备”
配置和使用设备仿真程序


如何：以 Visual Studio 中支持 KITL 的运行时映像为目标

[image]

设备仿真程序
如何：以 Visual Studio 中支持 KITL 的运行时映像为目标
请参见

如果在 Windows Mobile 中创建了一个运行时映像，并且将该映像下载到设备仿真程序（或物理设备），则通过将设备映像与已安装的 SDK 进行关联，可以从 Visual Studio 连接到该映像。以下步骤将指导您对目标设备和必需的服务进行配置。

注意 注意：

仅针对以太网连接：如果开发计算机和目标设备不是位于同一子网，则无法连接到目标设备。

执行下列过程：

  • 开发计算机上必须安装 Visual Studio、Platform Builder 5.0 或更高版本，以及支持 KITL 的 SDK。

  • 必须已在启用了 KITL 的情况下对运行时图像进行了编译，并且已从 Platform Builder 打开了运行时图像。

注意 注意：

对于在以下说明中使用的某些 Visual Studio 用户界面元素，您的计算机可能会显示不同的名称或位置。这些元素取决于您所使用的 Visual Studio 版本和您所使用的设置。有关更多信息，请参见 Visual Studio 设置。

配置设备

  1. 在 Platform Builder 的“目标”菜单上单击“连接选项”。

  2. 单击“添加设备”。

  3. 在“关联的 OS 设计/SDK (可选)”下拉列表中，选择要与目标设备关联的 SDK 平台的名称。

  4. 在“新目标设备名称”框中，键入目标设备的名称。

    - 或 -

    如果要使用现有的设备，则请验证“新目标设备名称”框是否为空白。

  5. 单击“添加”。

配置内核服务

  1. 选择“内核服务映射”。

  2. 在“目标设备”框中，选择要连接的目标设备的名称。

  3. 在“下载”框中，选择一项下载服务。

  4. 在“下载”框的右侧单击“设置”。

  5. 配置下载服务的设置，然后单击“确定”。

  6. 在“传输”框中，选择一个内核传输。

  7. 在“传输”框的右侧单击“设置”。

  8. 配置传输服务的设置，然后单击“确定”。

  9. 在“调试器”框中选择以下设置之一：

    • 如果运行时图像包含对 KdStub（内核调试器存根）的支持，请单击“KdStub”。

    • 如果运行时映像包含对硬件辅助调试的支持，则请选择合适的硬件辅助调试器。

    • 如果运行时图像不包含对调试器的支持，请单击“无”。

配置核心服务

  1. 单击“核心服务设置”。

  2. 在“下载映像”下选择以下设置之一：

    • 若要指示 Platform Builder 在每次与目标设备连接时都下载运行时映像，请选择“总是”。

    • 若要指示 Platform Builder 在开发计算机上的运行时映像与目标设备上的运行时映像不相同的时候下载运行时映像，请选择“仅在映像更改时”。

    • 若要指示 Platform Builder 仅在首次与目标设备相连时下载运行时映像，请选择“仅在初次下载时”。

    • 若要指示 Platform Builder 跳转到目标设备上的运行时映像，请选择“从不(仅跳转到映像)”。

  3. 单击“应用”。

请参见

概念

配置和使用设备仿真程序


如何：模拟热启动或冷启动

[image]

设备仿真程序
如何：模拟热启动或冷启动
请参见

可以使用仿真程序模拟移动设备的热启动或冷启动。

模拟热启动

  • 在设备仿真程序的“文件”菜单上单击“重置”，再单击“软件”。

    “软件重置”将重新启动设备，同时保持当前的文件存储和注册表信息不变。

使用 Platform Builder 模拟热启动

  • 从 Platform Builder 的“目标”菜单项中，单击“重置设备”。

模拟冷启动

  • 在设备仿真程序的“文件”菜单上单击“重置”，再单击“硬件”。

    “硬件重置”将重新加载默认出厂设置（包括 OS 图像），放弃任何用户更改。

请参见

概念

如何：启动设备仿真程序
配置和使用设备仿真程序


如何：将 Platform Builder 附加到运行的仿真程序

[image]

设备仿真程序
如何：将 Platform Builder 附加到运行的仿真程序
请参见

若要将 Platform Builder 附加到正在运行的设备仿真程序实例，则必须使用 eboot.nb0 映像启动设备仿真程序。如果使用内核 .bin 文件启动设备仿真程序，则运行时映像启动时不具有内核独立传输层 (KITL)，并且无法将其附加到 Platform Builder 以进行虚拟计算机会话。

附加到正在运行的设备仿真程序

  1. 使用 eboot.nb0 映像文件从命令行启动设备仿真程序。

    有关更多信息，请参见如何：启动设备仿真程序。

  2. 打开设备仿真程序之后，打开 Platform Builder。

  3. 在“目标”菜单上单击“连接选项”。

  4. 在左窗格中，选择“内核服务映射”。

  5. 在“下载”框中：

    • 如果已启动运行时映像，则选择“无”；或

    • 选择“以太网”，以使用以太网下载运行时映像。

  6. 单击“设置”。

  7. 在“仿真程序属性”对话框中，修改设备仿真程序的设置，然后单击“确定”。

  8. 在“传输”框中，选择“以太网”。

  9. 单击“核心服务设置”。在“KITL 设置”中，选择以下所需的任何设置：

    • 启用 KITL。

    • 启用桌面文件访问。

    • 软件重置时清除内存

  10. 单击“应用”。

  11. 在“目标”菜单上单击“附加设备”。

请参见

概念

如何：启动设备仿真程序
配置和使用设备仿真程序


如何：关闭设备仿真程序

[image]

设备仿真程序
如何：关闭设备仿真程序
请参见

可以使用设备仿真程序管理器或设备仿真程序本身关闭仿真程序。

  • 如果从仿真程序窗口关闭，则该仿真程序会提示是否要保存仿真程序的状态。有关保存状态的更多信息，请参见 保存状态的文件。

  • 如果从设备仿真程序管理器关闭该仿真程序，则状态不会保存。

从仿真程序窗口关闭设备仿真程序

  • 在“设备仿真程序”窗口中，单击“文件”，再单击“退出”。

    - 或 -

  • 在“设备仿真程序”窗口中单击右上角的“关闭”（“X”）。

从设备仿真程序管理器关闭设备仿真程序

  1. 在“设备仿真程序管理器”窗口中，右击要关闭的仿真程序实例。

  2. 在快捷菜单上单击“关闭”。

请参见

概念

配置和使用设备仿真程序
设备仿真程序管理器


如何：配置远程工具通信

[image]

设备仿真程序
如何：配置远程工具通信
请参见

可以使用远程工具（如远程注册表编辑器或远程消息监视程序）在设备仿真程序上测试运行时图像。启动远程工具的方式视具体安装情况而定。

注意 注意：

对于在以下说明中使用的某些 Visual Studio 用户界面元素，您的计算机可能会显示不同的名称或位置。这些元素取决于您所使用的 Visual Studio 版本和您所使用的设置。有关更多信息，请参见 Visual Studio 设置。

Visual Studio 2008

启动远程工具

  • 在 Windows 桌面上单击“开始”，依次指向“所有程序”和“Microsoft Visual Studio 2008”，单击“Visual Studio 远程工具”，然后从菜单中选择一个远程工具。

Platform Builder

为设备仿真程序连接配置远程工具

  1. 下载要使用的运行时映像。有关更多信息，请参见 如何：将运行时映像下载到仿真程序。

  2. 在 Platform Builder 的“工具”菜单上，选择任一远程工具。

  3. 在“远程工具”窗口的“连接”菜单中单击“配置 Windows CE 平台管理器”。

  4. 展开“Windows CE 默认平台”节点。

    - 或 -

    展开要配置的设备节点。

  5. 选择“默认设备”，然后单击“属性”。

    - 或 -

    如果已创建了一个设备，则请选择该设备的项，然后单击“属性”。

  6. 在“传输”框中，选择一个传输，然后单击“配置”。

  7. 自定义该传输的设置，然后单击“确定”。

  8. 在“启动服务器”框中，选择启动服务器，然后单击“配置”。

  9. 自定义该启动服务器的设置，然后单击“确定”。

  10. 单击“确定”。

请参见

概念

配置和使用设备仿真程序


如何：更改以太网设置

[image]

设备仿真程序
如何：更改以太网设置
请参见

可以从“设备仿真程序”窗口、Platform Builder 或 Visual Studio 更改为设备仿真程序提供以太网支持的网卡模拟。

注意 注意：

以太网支持仅在安装了虚拟交换机驱动程序的情况下可用。可以从 Mobile Developer Center（移动开发人员中心）下载此驱动程序。

使用“设备仿真程序”窗口更改以太网支持设置

  1. 在设备仿真程序的“文件”菜单上单击“配置”。

  2. 在“仿真程序属性”对话框中单击“网络”选项卡。

  3. 选择要仿真的网卡，然后单击“确定”。

使用 Platform Builder 更改以太网支持设置

  1. 在 Platform Builder 的“目标”菜单上单击“连接选项”。

  2. 单击“内核服务映射”。

  3. 在“下载”框中，验证是否选择了“设备仿真程序”，然后单击“设置”。

  4. 在“仿真程序属性”对话框中，选择“网络”选项卡。

  5. 选择要仿真的网卡，然后单击“确定”。

  6. 选择“应用”。

使用 Visual Studio 更改以太网支持设置

  1. 在 Visual Studio 的“工具”菜单上单击“选项”。

  2. 在“选项”对话框中，展开“设备工具”，然后单击“设备”。

  3. 选择要更改其设置的仿真程序，然后单击“属性”。

  4. 在“仿真程序属性”对话框中单击“网络”选项卡。

  5. 选择要仿真的网卡，然后单击“确定”。

请参见

概念

如何：启动设备仿真程序
配置和使用设备仿真程序


如何：将目录映射到设备仿真程序

[image]

设备仿真程序
如何：将目录映射到设备仿真程序
请参见

可以将设备仿真程序连接到开发计算机上的目录，将该目录作为安装到该设备仿真程序上的驱动器使用。在设备仿真程序的文件系统中，连接的目录作为存储卡出现在根级别。

设备仿真程序每次只能连接到一个目录。

安全说明 安全说明：

只要使用文件夹共享功能，就会带来潜在的安全风险。例如，对于包含保密或敏感信息的目录，请不要启用共享。

将目录映射到设备仿真程序

  1. 在设备仿真程序上，运行支持连接到开发计算机上的目录的 Windows CE OS。

  2. 在设备仿真程序的“文件”菜单上单击“配置”。

  3. 在“仿真程序属性”对话框中，选择“常规”选项卡。

  4. 在“共享文件夹”框中，键入要映射的目录的路径和文件夹名称。

    - 或 -

    单击“浏览”按钮，定位到要共享的目录，然后单击“确定”。

  5. 单击“确定”。

请参见

概念

如何：启动设备仿真程序
配置和使用设备仿真程序


如何：从设备仿真程序中移除映射的目录

[image]

设备仿真程序
如何：从设备仿真程序中移除映射的目录
请参见

如果以前已经将目录映射到设备仿真程序，则可以通过使用“仿真程序属性”对话框移除该映射。通过 Platform Builder、Visual Studio 以及“设备仿真程序”窗口（如以下任务中所述）可使用此对话框。有关更多信息，请参见如何：更改属性设置。

从设备仿真程序中移除映射目录

  1. 在设备仿真程序的“文件”菜单上单击“配置”。

  2. 在“仿真程序属性”对话框中，选择“常规”选项卡。

  3. 在“共享文件夹”框中，删除路径和文件夹。

请参见

概念

如何：将目录映射到设备仿真程序
配置和使用设备仿真程序


如何：使用文件夹共享模拟存储卡

[image]

设备仿真程序
如何：使用文件夹共享模拟存储卡
请参见

当对仿真程序共享某文件夹时，该文件夹显示为存储卡。仿真程序将共享文件夹存储卡视为真正的设备进行操作。当不想继续使用仿真存储卡时，还可以停止文件夹共享。

安全说明 安全说明：

只要使用文件夹共享功能，就会带来潜在的安全风险。例如，对于包含保密或敏感信息的目录，请不要启用共享。

激活文件夹共享

  1. 在设备仿真程序的“文件”菜单上单击“配置”。

  2. 选择“常规”选项卡。

  3. 在“共享文件夹”框中，键入要用作仿真存储卡的目录的路径和文件夹名称。

    - 或 -

    单击“浏览”按钮，定位到要用作仿真存储卡的目录，然后单击“确定”。

  4. 单击“确定”。

停止文件夹共享

  1. 在设备仿真程序的“文件”菜单上单击“配置”。

  2. 选择“常规”选项卡。

  3. 在“共享文件夹”框中，删除用作仿真存储卡的目录的路径和文件夹名称。

  4. 单击“确定”。

请参见

概念

如何：启动设备仿真程序
配置和使用设备仿真程序


如何：将文件移入和移出设备仿真程序

[image]

设备仿真程序
如何：将文件移入和移出设备仿真程序
请参见

若要将文件移入和移出设备仿真程序，请使用共享文件夹。

有关创建共享文件夹的信息，请参见 如何：将目录映射到设备仿真程序。

安全说明 安全说明：

只要使用文件夹共享功能，就会带来潜在的安全风险。例如，对于包含保密或敏感信息的目录，请不要启用共享。

使用共享文件夹将文件移入或移出仿真程序

  1. 在开发计算机上创建一个共享文件夹。

  2. 若要将文件移入或移出设备仿真程序，请将该文件移入（或复制到）或移出共享文件夹目录。

请参见

概念

配置和使用设备仿真程序


如何：将设备仿真程序插入底座和移除底座

[image]

设备仿真程序
如何：将设备仿真程序插入底座和移除底座
请参见

使用设备仿真程序管理器将仿真程序插入底座和移出底座，模拟将物理设备插入底座和移出底座。

要执行这些任务，必须连接到设备仿真程序实例。

将设备仿真程序插入底座和移除底座

  1. 启动设备仿真程序管理器。

    有关启动设备仿真程序管理器的更多信息，请参见 如何：启动设备仿真程序管理器。

  2. 在“设备仿真程序管理器”窗口中右击已连接的仿真程序实例。

  3. 在快捷菜单上单击“插入底座”或“移除底座”。

请参见

概念

如何：启动设备仿真程序管理器
配置和使用设备仿真程序
设备仿真程序管理器


如何：调整设备仿真程序中 RAM 的大小

[image]

设备仿真程序
如何：调整设备仿真程序中 RAM 的大小
请参见

可以将 RAM 的大小更改为 OS 映像支持的任何值。使用此功能可更逼真地模仿您正在仿真的物理设备中的 RAM 状况。

如果在仿真程序运行时更改 RAM 大小，必须重新启动仿真程序以使更改生效。

有些映像可能不支持调整 RAM 的大小。

使用 Visual Studio 调整 RAM 的大小

  1. 在 Visual Studio 的“工具”菜单上依次单击“选项”、“设备工具”和“设备”，选择要更改 RAM 的仿真程序，单击“属性”，再单击“仿真程序选项”。

  2. 在“常规”选项卡上，选择“指定 RAM 大小”。

使用 Platform Builder 调整 RAM 的大小

  1. 在 Platform Builder 的“目标”菜单上单击“连接选项”。

  2. 选择“内核服务映射”。

  3. 在“下载”框中，选择“设备仿真程序”。

  4. 在“下载”框的右侧单击“设置”。

  5. 在“常规”选项卡上，选择“指定 RAM 大小”。

使用命令行调整 RAM 的大小

  • 使用 /memsize 开关从命令行启动设备仿真程序。

    有关更多信息，请参见如何：启动设备仿真程序。

请参见

概念

设备仿真程序命令行参考
配置和使用设备仿真程序


如何：指定共享文件夹

[image]

设备仿真程序
如何：指定共享文件夹
请参见

使用共享文件夹仿真存储卡、移动文件，等等。

安全说明 安全说明：

只要使用文件夹共享功能，就会带来潜在的安全风险。例如，对于包含保密或敏感信息的目录，请不要启用共享。

指定共享文件夹

  1. 在设备仿真程序的“文件”菜单上单击“配置”。

  2. 在“常规”选项卡上，通过插入名称或使用“省略号”（“…”）按钮定位到文件夹来指定共享文件夹。

请参见

概念

如何：启动设备仿真程序
如何：将文件移入和移出设备仿真程序
配置和使用设备仿真程序
如何：使用文件夹共享模拟存储卡
如何：从设备仿真程序中移除映射的目录


如何：指定主机键

[image]

设备仿真程序
如何：指定主机键
请参见

仿真程序正在运行时，可以使用开发计算机的键盘控制某些仿真程序操作，如显示其快捷菜单等。通过预定义组合键（包含一个主机键和一个或多个其他键）可实现此技术。仿真程序将这些组合键识别为命令。有关更多信息，请参见 设备仿真程序组合键。

指定主机键

  1. 在设备仿真程序的“文件”菜单上单击“配置”。

  2. 在“常规”选项卡上，选择主机键。

请参见

概念

如何：启动设备仿真程序
配置和使用设备仿真程序


如何：指定外观文件

[image]

设备仿真程序
如何：指定外观文件
请参见

可以通过指定一个 xml 外观定义文件来指定设备仿真程序的外观。

有关外观定义文件的更多信息，请参见 设备仿真程序外观 XML 架构参考。

指定外观文件

  1. 在设备仿真程序的“文件”菜单上单击“配置”。

  2. 在“显示”选项卡上，选择“外观”。

  3. 插入外观文件名称，或通过单击“省略号”（“…”）按钮导航到该文件。

请参见

概念

如何：启动设备仿真程序
配置和使用设备仿真程序
外观
“仿真程序属性”对话框 ->“显示”
如何：自定义仿真程序的外观


如何：更改外观方向

[image]

设备仿真程序
如何：更改外观方向
请参见

使用此功能从纵向更改为横向，或旋转“仿真程序属性”对话框中提供的任何度数。

更改外观方向

  1. 在设备仿真程序的“文件”菜单上单击“配置”。

  2. 在“显示”选项卡上，选择旋转的度数。

请参见

概念

如何：启动设备仿真程序
配置和使用设备仿真程序


如何：启用仅主机网络

[image]

设备仿真程序
如何：启用仅主机网络
请参见

仅主机网络提供台式计算机和设备仿真程序之间的网络连接。此网络完全包含在主机内。

启用仅主机网络

  1. 在设备仿真程序的“文件”菜单上单击“配置”。

  2. 在“网络”选项卡上，选择“仅主机网络”。

请参见

概念

如何：启动设备仿真程序
配置和使用设备仿真程序


如何：映射串行端口

[image]

设备仿真程序
如何：映射串行端口
请参见

设备仿真程序提供了三个串行端口（虚拟 COM 端口），可以将其映射到开发计算机上的 COM 端口。

映射串行端口

  1. 在设备仿真程序的“文件”菜单上单击“配置”。

  2. 在“外围设备”选项卡上指定映射。

    有关更多信息，请参见 “仿真程序属性”对话框 ->“外围设备”。

请参见

概念

如何：启动设备仿真程序
配置和使用设备仿真程序


如何：启用工具提示

[image]

设备仿真程序
如何：启用工具提示
请参见

仿真程序上的工具提示显示外观功能的标签，如“功能键 1”。

启用工具提示

  1. 在设备仿真程序的“文件”菜单上单击“配置”。

  2. 在“显示”选项卡上，单击“启用工具提示”。

请参见

概念

如何：启动设备仿真程序
配置和使用设备仿真程序


如何：自定义仿真程序的外观

[image]

设备仿真程序
如何：自定义仿真程序的外观
请参见

下列步骤描述如何为设备仿真程序开发自定义外观，然后描述如何在 Platform Builder 和 Visual Studio 中将该外观应用于仿真程序。

开发自定义外观

  1. 创建一个位图 (BMP) 或可移植网络图形 (PNG) 文件，此文件显示仿真程序的默认外观。

  2. 创建一个 BMP 或 PNG 文件，此文件显示所有按钮均为按下状态的仿真程序外观。

  3. 创建一个 BMP 或 PNG 文件，此文件显示每个按钮的区域由一种颜色填充。

  4. 如果希望每个按钮的外观不随着仿真程序外观中的其他按钮发生更改，则请使用不同颜色填充每个按钮的区域。

    注意 注意：

    为了获得最佳视觉效果，请勿使用白色或黑色填充该区域。

  5. 创建 .xml 外观定义文件。

    有关更多信息，请参见设备仿真程序外观 XML 架构参考。

  6. 将这三个 BMP 或 PNG 文件和.xml 文件保存到同一个目录。

在 Platform Builder 项目中使用外观

  1. 在 Platform Builder 的“目标”菜单上单击“连接选项”。

  2. 在“下载”框中，选择“设备仿真程序”。

  3. 在“下载”框的右侧单击“设置”。

  4. 在“仿真程序属性”对话框中单击“显示”选项卡。

  5. 选择“外观”，然后定位到定义自定义外观的 .xml 文件所在的位置。

在 Visual Studio 项目中使用外观

  1. 在 Visual Studio 的“工具”菜单上单击“选项”。

  2. 展开“设备工具”节点，然后单击“设备”。

  3. 在“设备”框中，选择要向其添加外观的仿真程序，然后单击“属性”。

  4. 在“<DeviceName> 仿真程序属性”对话框中单击“仿真程序选项”。

  5. 在“仿真程序属性”对话框中单击“显示”选项卡。

  6. 选择“外观”，然后定位到定义自定义外观的 .xml 文件所在的位置。

请参见

概念

外观
设备仿真程序外观 XML 架构参考
配置和使用设备仿真程序


如何：访问 Smartphone 仿真程序文件系统

[image]

设备仿真程序
如何：访问 Smartphone 仿真程序文件系统
请参见

Smartphone 仿真程序没有资源管理器。使用以下技术来访问 Smartphone 文件系统。

注意 注意：

此技术仅在 Visual Studio 中可用。

访问 Smartphone 仿真程序文件系统

  1. 在 Visual Studio 的“工具”菜单上，单击“设备仿真程序管理器”。

  2. 在“可用的仿真程序”窗格中，选择您要访问其文件系统的仿真程序。

  3. 在设备仿真程序管理器的“操作”菜单上，单击“连接”。

    所选仿真程序旁会显示一个图标，指示已建立连接。

  4. 右击所选仿真程序，然后单击“插入底座”。

    该图标改为显示已插入底座的仿真程序。

  5. 打开 ActiveSync。

  6. 在 ActiveSync 的“文件”菜单上，单击“连接设置”。

  7. 选择“允许连接到下列端口之一”。

  8. 从端口列表中选择“DMA”，然后单击“确定”。

    ActiveSync 将立即使用仿真程序启动伙伴关系。按照“新建合作关系”向导提供的说明执行操作。

    注意 注意：

    如果未自动启动合作关系，请在“连接设置”对话框中单击“连接”，然后按照“进行连接”向导中的提示执行操作。

  9. 完成建立 ActiveSync 合作关系的步骤后，在 ActiveSync 工具栏上单击“浏览”以访问仿真程序的文件系统。

    注意 注意：

    如果关闭设备仿真程序管理器或关闭仿真程序，则 ActiveSync 连接也将关闭。

请参见

概念

配置和使用设备仿真程序


如何：显示 Smartphone 仿真程序的 IP 地址

[image]

设备仿真程序
如何：显示 Smartphone 仿真程序的 IP 地址
请参见

发掘 Smartphone 仿真程序的 IP 地址需要编程方法。下列步骤演示如何创建和运行一个这样的例程。

创建例程

  1. 在 Visual Studio 中，打开一个新的 C# Smartphone 空项目。

  2. 在“解决方案资源管理器”中，右击项目，指向“添加”，然后单击“新建项”。

  3. 单击“代码文件”，然后单击“添加”。

    代码编辑器打开空白页面。

  4. 将以下代码块复制到编辑器页面。

    “复制”图像 复制代码
    using System;
using System.Net;
using System.Text;
using System.Windows.Forms;

public class GetAddress
{
    /// <summary>
    /// A sample application that displays a list of IP addresses
    /// that are bound to the current device.
    /// </summary>

    static void Main()
    {
        try
        {
            IPHostEntry IPHost = Dns.Resolve(Dns.GetHostName());
            IPAddress[] addressList = IPHost.AddressList;

            if (addressList.Length > 0)
            {
                StringBuilder address = new StringBuilder();
                foreach (IPAddress a in addressList)
                {
                    address.Append(a.ToString());
                    address.Append(" ");
                }
                MessageBox.Show(address.ToString(), "IP Addresses");
            }

            else
                MessageBox.Show("Unable to determine network address", "Error");
        }

        catch (Exception)
        {
            MessageBox.Show("Unable to determine network address", "Error");
        }
    }
}

  5. 在“解决方案资源管理器”中，右击“引用”，然后单击“添加引用”。

  6. 单击“System.Windows.Forms”，然后单击“确定”。

运行例程

  1. 在“调试”菜单上单击“启动调试”。

  2. 在“部署”对话框中，单击要显示其 IP 地址的 Smartphone 仿真程序。

  3. 单击“部署”。

    应用程序显示 IP 地址。

请参见

概念

配置和使用设备仿真程序
连接问题疑难解答


如何：模拟耳机、话筒或车载的存在

[image]

设备仿真程序
如何：模拟耳机、话筒或车载的存在
请参见

设备仿真程序可以模拟话筒、耳机和车载硬件。

注意 注意：

为了使此操作能够执行，仿真程序操作系统 (OS) 映像必须支持设备仿真程序的耳机、话筒或车载硬件仿真。Windows Mobile 6 中引入了对于这些功能的 OS 映像支持。

如果您要测试应用程序在插入或拔出耳机、话筒或车载时能否收到通知，则对硬件进行模拟十分有用。例如，在插入耳机时，应用程序可能会自动使板载麦克风和扬声器处于静音状态。通过使用状态和通知中间装置，应用程序可以检测到话筒、耳机或车载硬件的存在。有关更多信息，请参见 The State and Notifications Broker Part I（状态和通知中间装置：第一部分）

插入或拔出耳机、话筒或车载

  1. 启动设备仿真程序。

    有关更多信息，请参见如何：启动设备仿真程序。

  2. 在设备仿真程序的“文件”菜单上单击“配置”。

  3. 在“外围设备”选项卡上，选中或清除“话筒”、“耳机”或“车载”。

  4. 单击“确定”。

    如果仿真程序操作系统映像支持话筒、耳机和/或车载硬件，则下列注册表项中一个或多个注册表项的值会发生更改：

    • HKEY_LOCAL_MACHINE\System\State\Hardware\Headset

    • HKEY_LOCAL_MACHINE\System\State\Hardware\Car Kit

    • HKEY_LOCAL_MACHINE\System\State\Hardware\Speaker

    请使用 Remote Registry Editor（远程注册表编辑器）或其他注册表工具查看这些更改。

请参见

概念

“仿真程序属性”对话框 ->“外围设备”


如何：在设备仿真程序上调整电池设置

[image]

设备仿真程序
如何：在设备仿真程序上调整电池设置
请参见

设备仿真程序可以模拟电池的存在。

注意 注意：

若要实现此操作，仿真程序操作系统 (OS) 映像必须支持设备仿真程序的电池仿真。 Windows Mobile 6 中引入了对电池仿真的 OS 映像支持。

模拟电池或交流电源

  1. 启动设备仿真程序。

    有关更多信息，请参见如何：启动设备仿真程序。

  2. 在设备仿真程序的“文件”菜单上单击“配置”。

  3. 在“外围设备”选项卡上，选中“电池”以使用电池电源，或清除“电池”以使用交流电源。

  4. 如果选中“电池”，请在“%”中键入一个 0 到 100 范围内的整数。

  5. 单击“确定”。

    现在，设备仿真程序的运行由电池提供电源。

请参见

概念

“仿真程序属性”对话框 ->“外围设备”


如何：在设备仿真程序上启用 TCP/IP 网络

[image]

智能设备开发
如何：在设备仿真程序上启用 TCP/IP 网络
请参见

在设备仿真程序上启用 TCP/IP 网络时，仿真程序可以在不插入底座的情况下连接到 Internet 并与 Microsoft Exchange 同步。

本主题描述如何在不使用 ActiveSync 或 Windows Mobile 设备中心（在 Windows Vista 中）的情况下启用 TCP/IP 网络。本主题还描述如何在虚拟机中运行的仿真程序上启用专用 TCP/IP 网络。

在设备仿真程序中启用 TCP/IP 网络

在设备仿真程序中启用 TCP/IP 网络

  1. 通过安装 Virtual PC 2007（虚拟 PC 2007）来安装虚拟机网络驱动程序。

  2. 将设备仿真程序的网络适配器绑定到主机的网络适配器：

    1. 在设备仿真程序的“文件”菜单上单击“配置”。

    2. 在“网络”选项卡上，选中“启用 NE2000 PCMCIA 网络适配器”并在下拉菜单中选择“连接的网卡”。

    3. 单击“确定”。

    默认情况下，设备仿真程序通过向 DHCP 服务器广播来获取 IP 地址。

  3. （可选）根据网络的配置，可能需要用正确的代理设置来配置仿真程序的操作系统映像。

在虚拟机中启用专用 TCP/IP 网络

内部过程是不同的，这是因为出于安全原因，虚拟 PC 和虚拟服务器会阻止虚拟机中运行的虚拟交换机网络驱动程序接收广播网络数据包。因此，虚拟机中运行的设备仿真程序无法从网络的 DHCP 服务器获取 IP 地址。

在虚拟机中运行的设备仿真程序上启用专用 TCP/IP 网络

  1. 在虚拟机上安装 Microsoft 环回适配器：

    1. 启动“控制面板”。

    2. 单击“经典视图”，然后双击“添加硬件”。

      出现向导。

    3. 单击“下一步”。

    4. 单击“安装我手动从列表选择的硬件(高级)”，然后单击“下一步”。

    5. 在“常见硬件类型”列表中，选择“网络适配器”，然后单击“下一步”。

    6. 在“制造商”列表中，选择“Microsoft”。

    7. 在“网络适配器”列表中，选择“Microsoft 环回适配器”。

    8. 单击“下一步”。

      “添加硬件向导”完成安装。

  2. 将设备仿真程序的网络适配器绑定到环回适配器：

    1. 在设备仿真程序的“文件”菜单上单击“配置”。

    2. 在“网络”选项卡上，选中“启用 NE2000 PCMCIA 网络适配器”并在下拉菜单中选择“Microsoft 环回适配器”。

    3. 单击“确定”。

    虚拟机和设备仿真程序即分配了自动专用 IP 地址 (169.254.xxx.xxx)，只能在环回适配器创建的专用网络上相互通信。如果正在虚拟机中运行仿真程序，又希望与虚拟机中的服务器应用程序（如 Internet 信息服务 (IIS) 和 Exchange）通信时，这会十分有用。

    注意 注意：

    在这种情况下，虚拟机中运行的设备仿真程序不能与 Internet 或运行虚拟机的计算机进行通信。

请参见

概念

配置和使用设备仿真程序


设备仿真程序参考

[image]

设备仿真程序
设备仿真程序参考

这些主题提供有关设备仿真程序和外观的参考信息。

本节内容

设备仿真程序命令行参考

提供从命令行启动设备仿真程序的语法。

Imagegen 命令行参考

提供启动 Imagegen 工具的语法。

设备仿真程序外观 XML 架构参考

提供用于为设备仿真程序开发自定义外观文件的 XML 模型。

设备仿真程序组合键

在开发计算机上指定可用来控制所运行的仿真程序的某些方面的组合键。

设备仿真程序用户界面参考

描述用于配置设备仿真程序的对话框。

相关章节

设备仿真程序


设备仿真程序命令行参考

[image]

设备仿真程序
设备仿真程序命令行参考
示例 请参见

使用下面的语法在命令提示符处启动设备仿真程序。除非使用 /s 或 @decfg_filename 命令行选项，否则 os_image_file_name 是必需的。

注意 注意：

有些 SDK 并不支持所有选项。有关更多信息，请参见 SDK 文档。

DeviceEmulator os_image_file_name [/a] [/c] [/f [featurevalue]]
   [/flash [flash_file_name]] [/h] [/hostkey keyname]
   [/language LangID] [/memsize size] [/n [macaddress]]
      [/nosecurityprompt] [/p [macaddress]] [/r ROM_address]
   [/rotate angle] [/s save-state_file_name]
   [/sharedfolder directoryname] [/skin skin_file_name] [/tooltips
        state] [/u0 serialport] [/u1 serialport] [/u2 serialport]
      [/video <width>x<height>x<bit depth>] [/vmid {GUID}]
   [/vmname name] [/z]

参数

参数 | 说明
os_image_file_name | 指定仿真程序要使用的内核映像的路径和文件名称（*.bin 或 *.nb0）。 通过使用 /s 命令行选项，可以从内核映像、设备仿真程序配置文件或保存状态文件启动设备仿真程序。
@decfg_filename | 指定要使用的设备仿真程序配置文件 (*.decfg) 的路径和文件名。 通过使用 /s 命令行选项，可以从内核映像、设备仿真程序配置文件或保存状态文件启动设备仿真程序。

开关

开关

说明

/a

即使没有焦点，也使仿真程序窗口始终保持在最前面。

/battery

指定电池电源。如果该选项不存在，则仿真程序默认为使用交流电源。

/batterycharge [n]

指定电池电量，以从 0 到 100 的百分比 n 表示。如果该选项不存在，则电量默认为 100%。

/c

创建并显示一个控制台窗口以显示 Windows CE 调试串行端口的输出内容，用户键入的击键正是传送到此控制台。该技术对于从 Platform Builder 观察调试输出和下载内核映像非常有用。

/cpucore

ARMv4 或 ARMv5。默认值为 ARMv4。

/cpuoptions

(T)humb、(D)ebug、(I)nternetworking、(M)Long Multiply、(e)DSP 的组合。在这些选项中，总是会设置 T、D 和 I。

/defaultsave

使用 VMID 作为保存状态名称，并将保存状态文件放到每个用户的目录中。

注意 注意：

不能同时指定 /defaultsave 和 /s。

/funckey [value]

这是一个特殊的开关，其值通常为 193。使用值 193 会将键盘功能键（F1、F2 等）映射到设备仿真程序的软键。

/flash [flash_file_name]

启用闪存仿真，其中的可选 flash_file_name 指定要用作闪存存储的文件的名称。

/h

为网络数据包设置仅主机路由。影响 CS8900 和 NE2000 网卡。

/hostkey keyname

指定主机键，其中的 keyname（区分大小写）可以是 None、Left-Alt 或 Right-Alt。

/language LangID

指定 UI 语言，其中的 LangID 为四位数字的十进制数。

/memsize size

设置仿真的 RAM 大小，其中 size 以 MB 为单位。有效值为从 64 到 256（含）。如果未指定有效值，则 size 默认为 64。

/n [macaddress]

启用 CS8900 网络适配器，其中可选的 macaddress 是一个十二位数字的十六进制数，指定卡将绑定到哪个主机适配器。

/nosecurityprompt

当已保存状态文件使用网络连接、串行端口和文件夹共享时，禁用启用它们的提示。

安全说明 安全说明：

只要使用文件夹共享功能，就会带来潜在的安全风险。例如，对于包含保密或敏感信息的目录，请不要启用共享。

/p [macaddress]

启用 NE2000 PCMCIA 网络适配器，其中可选的 macaddress 是一个十二位数字的十六进制数，指定卡将绑定到哪个主机适配器。

/r ROM_address

指定 ROM 文件基址，其中 ROM_address 可以是十六进制数或十进制数。

/rotate angle

按度数顺时针旋转显示屏，其中 angle 可以是 0、90、180 或 270。允许使用其他整数值，但是要四舍五入到最接近于 90 的整数倍数的值。

/s filename

启用保存状态支持，其中 filename 是保存状态文件的名称。

安全说明 安全说明：

使用来自不受信任来源的已保存状态文件会导致安全风险。

请注意 /s 开关的以下行为：

  • 如果指定了 ROM 映像文件名但没有指定 /s filename，则仿真程序会从 ROM 映像冷启动，并禁用保存状态。

  • 如果指定了 ROM 映像文件名和 /s filename，则仿真程序从 ROM 映像冷启动，并在退出时启用保存状态，将状态保存到指定的文件名。

  • 如果没有指定 ROM 映像，则 /s filename 必须存在，并且仿真程序将从指定的保存状态文件还原。当该仿真程序退出时，它会将新状态保存到保存状态文件的最前面。

    注意 注意：

    不能同时指定 /defaultsave 和 /s。

/sharedfolder directoryname

将一个目录作为共享文件夹装入，其中 directoryname 为 Windows 目录。该目录被作为来宾“\Storage File”装入，就像是一个存储卡。

/skin skin_file_name

加载指定的外观文件。

注意 注意：

不能同时指定 /skin 和 /video。

/tooltips on|off

启用或禁用工具提示，其中 state 为 ON 或 OFF。

/u0 serialport

将来宾串行端口 0（仿真程序 COM1）映射到 Windows serialport。

/u1 serialport

将来宾串行端口 1（仿真程序调试输出）映射到 Windows serialport。

/u2 serialport

将来宾串行端口 2（仿真程序 COM3）映射到 Windows serialport。

/vfp true|false

指定是否存在向量浮点协处理器。默认值为 false。

/video <width>x<height>x<bit-depth>

指定 LCD 窗口的屏幕大小和位深度，其中 width、height 和 bit-depth 为十进制值。例如：640x480x16。

注意 注意：

不能同时指定 /skin 和 /video。

/vmid {GUID}

指定要与仿真程序当前实例关联的 VMID GUID。它通常不在独立方案中传递。

如果没有 {GUID}，则会在不进行提示的情况下为该会话创建一个。

/vmname name

指定窗口标题。注意下面的行为：

  • 如果 /vmid 开关不存在但 /skin 存在，则由外观提供窗口标题。

  • 如果 /vmid 和 /skin 都不存在，则“设备仿真程序”显示为窗口标题。

/z

将显示窗口（外观和 LCD 窗口）放大为正常大小的 2 倍。

/speakerphone [n]

指定是否存在话筒、耳机和/或车载。n 是一个介于 0 和 7 之间的位图化编号，它们的含义为：

  • 0 – 无

  • 1 - 车载

  • 2 - 耳机

  • 3 - 耳机、车载

  • 4 - 话筒

  • 5 – 话筒、车载

  • 6 – 话筒、耳机

  • 7 – 话筒、耳机、车载

示例

下面的示例启动 Windows Mobile 5.0 Pocket PC 仿真程序：

注意 注意：

仿真程序操作系统映像可能位于计算机上的另一个文件夹中。

“复制”图像 复制代码
DeviceEmulator.exe "c:\Program Files\Windows Mobile 5.0 SDK R2\PocketPC
\Deviceemulation\0409\PPC_USA.BIN" /a /battery /batterycharge 40
/cpucore ARMv5 /memsize 256 /s "d:\MyCustomEmulator.dess" /skin
"c:\Program Files\Windows Mobile 5.0 SDK R2\PocketPC\Deviceemulation\
Pocket_pc\Pocket_PC.xml" /tooltips ON /vfp false
/vmname "My Custom Emulator" /z /speakerphone 7

然后，可以从“文件”菜单上选择“保存状态并退出”，并使用下面的命令再次从保存的状态文件中启动仿真程序：

“复制”图像 复制代码
DeviceEmulator.exe /s "d:\MyCustomEmulator.dess"

下面的示例从设备仿真程序配置文件中启动设备仿真程序。有关更多信息，请参见设备仿真程序配置文件。

“复制”图像 复制代码
DeviceEmulator.exe "@c:\My Emulator.decfg"

请参见

概念

设备仿真程序参考


Imagegen 命令行参考

[image]

设备仿真程序
Imagegen 命令行参考
示例 请参见

使用 Imagegen.exe 生成并存储设备仿真程序图像。

注意 注意：

您需要管理员权限，才能使用任何影响全局缓存的选项。全局缓存位于 驱动器:\Documents and Settings\All Users\Application Data\Microsoft\Device Emulator 下。

Imagegen.exe 包含在 Visual Studio 中，默认位置为 驱动器:\Program Files\Microsoft Device Emulator\1.0。

注意 注意：

默认情况下，Device Emulator 3.0 版会覆盖以前的安装，并且安装到 驱动器:\Program Files\Microsoft Device Emulator\1.0 下。

Imagegen [/i] [/g] [/l] [/u]

参数

选项 | 说明
/i | 标识要保存状态的设备的 GUID。
/g | 以全局保存状态缓存而不是每个用户的缓存为目标。
/l | 设置数据存储的区域设置 ID。 如果您不指定 ID，则 ID 值默认为 1033。
/u | 清除全局缓存。

示例

以下代码行指定日语数据存储、清除全局缓存，并且生成以全局缓存为目标的 Smartphone 和 Pocket PC 图像。

“复制”图像 复制代码
Imagegen /l 1041 /u /g /i E282E6BE-C7C3-4ece-916A-88FB1CF8AF3C /i DD63BCFB-BCB3-407c-9CDC-219A0240CBA0

请参见

概念

如何：生成保存状态文件
保存状态的文件
设备仿真程序参考


设备仿真程序配置 XML 架构参考

[image]

设备仿真程序
设备仿真程序配置 XML 架构参考
请参见

设备仿真程序配置 (.decfg) 文件是 XML 文件，这些文件包含确定设备仿真程序如何启动的设置。可以在 .decfg 文件中配置设置，如操作系统映像、外观、LCD 屏幕分辨率和网络。有关常规信息，请参见设备仿真程序配置文件。请使用下面的示例作为创作 .decfg 文件的参考。

代码

“复制”图像 复制代码
<?xml version="1.0"?>
<DeviceEmulator xmlns="http://schemas.microsoft.com/DeviceEmulator/2006/01/DeCfg">
  <Platform>My Plaform</Platform>
  <Emulator>
    <Language Reconfigurable="false">1033</Language>
    <AlwaysOnTop Reconfigurable="true">true</AlwaysOnTop>
    <ConsoleWindow Reconfigurable="false">true</ConsoleWindow>
    <HostKey Reconfigurable="true">Left-Alt</HostKey>
    <Rotation Reconfigurable="true">270</Rotation>
    <VMID Reconfigurable="false">{B89C49AD-197F-4CB4-A525-D81D0944EEAF}</VMID>
    <VMName Reconfigurable="true">My Custom Emulator</VMName>
    <!--<SaveState Reconfigurable="false">c:\1.dess</SaveState>-->
    <DefaultSave Reconfigurable="false">true</DefaultSave>
    <Zoom Reconfigurable="true">true</Zoom>
    <Video Reconfigurable="false" Width="640" Height="480" BitsPerPixel="16"/>
    <FuncKey Reconfigurable="true">193</FuncKey>
    <!--<Skin Reconfigurable="true" EnableSkin="true" ToolTips="on">c:\Program Files\Windows Mobile 5.0 SDK R2\PocketPC\Deviceemulation\Pocket_pc\Pocket_PC.xml</Skin>-->
  </Emulator>
  <Board>
    <OSImage Reconfigurable="false" Address="0">d:\Program Files\Windows Mobile 5.0 SDK R2\PocketPC\Deviceemulation\0409\PPC_USA.BIN</OSImage>
    <Flash Reconfigurable="false" Enabled="true">c:\mark.txt</Flash>
    <MemSize Reconfigurable="false">256</MemSize>
    <CpuCore Reconfigurable="false">ARMv5</CpuCore>
    <CpuOptions Reconfigurable="false">TDI</CpuOptions>
    <VFP Reconfigurable="false">true</VFP>
  </Board>
  <Peripherals>
    <Battery Reconfigurable="true" IsOnAcPower="false" Charge="40"/>
    <SharedFolder Reconfigurable="true">c:\</SharedFolder>
    <CS8900_Networking Reconfigurable="false" Enabled="true">00001A1A190B</CS8900_Networking>
    <NE2000_Networking Reconfigurable="true" Enable="true">00001A1A190B</NE2000_Networking>
    <HostOnly Reconfigurable="true">true</HostOnly>
    <Speakerphone Reconfigurable="true" CarKit="true" Headset="true" Speakerphone="true"/>
    <SerialPort Reconfigurable="true" UARTNumber="0">COM3</SerialPort>
    <SerialPort Reconfigurable="true" UARTNumber="1">none</SerialPort>
    <SerialPort Reconfigurable="true" UARTNumber="2">none</SerialPort>
  </Peripherals>
</DeviceEmulator>

备注

下表描述了上面的代码示例中的每一个元素。

项

说明

<DeviceEmulator> tag

封装设备仿真程序配置的架构。在每个 .decfg 文件中仅使用一个标记。包含下列标记：

  • Platform

  • Emulator

  • Board

  • Peripherals

<Platform>My Plaform</Platform>

包含平台的名称。每个 <DeviceEmulator> 标记仅使用一个 <Platform> 标记。可在“设备仿真程序管理器”中看到的仿真程序按照平台标记中的值进行组织。

<Emulator> tag

包含下列标记：

  • Language

  • AlwaysOnTop

  • ConsoleWindow

  • HostKey

  • Rotation

  • VMID

  • VMName

  • SaveState

  • DefaultSave

  • Zoom

  • Video

  • FuncKey

  • Skin

<Language Reconfigurable="false">1033</Language>

指定用户界面 (UI) 语言，其中，值为四位十进制数。例如，1033 表示“美国英语”。

<AlwaysOnTop Reconfigurable="true">true</AlwaysOnTop>

使仿真程序窗口始终位于最上面，即使该窗口没有焦点。可以为 true 或 false。默认为 false。

<ConsoleWindow Reconfigurable="false">true</ConsoleWindow>

创建并显示一个控制台窗口以显示 Windows CE 调试串行端口的输出内容，用户键入的击键正是传送到此控制台。该技术对于从 Platform Builder 观察调试输出和下载内核映像非常有用。可以为 true 或 false。默认为 false。

<HostKey Reconfigurable="true">Left-Alt</HostKey>

指定主机键，其中的值（不区分大小写）可以为 None、Left-Alt 或 Right-Alt。

<Rotation Reconfigurable="true">270</Rotation>

按一定的度数顺时针旋转显示，旋转角度值可以为 0、90、180 或 270。其他整数值也可以接受，但是要向下舍入为最接近且为 90 的整数倍的值。

<VMID Reconfigurable="false">{B89C49AD-197F-4CB4-A525-D81D0944EEAF}</VMID>

指定要与仿真程序当前实例关联的 VMID GUID。

<VMName Reconfigurable="true">My Custom Emulator</VMName>

指定窗口标题。如果此标记不存在，则会按照外观标记或给定的默认名称“设备仿真程序”对窗口进行命名。

<!--<SaveState Reconfigurable="false">c:\1.dess</SaveState>-->

启用保存状态支持，其中，值是保存状态文件的名称。.decfg 文件必须指定 SaveState 或 OSImage 标记。请注意 SaveState 标记的下列特性：

  • 如果 SaveState 标记不存在而 OSImage 标记存在，则仿真程序会根据 OSimage 的值冷启动，并禁用保存状态。

  • 如果 SaveState 标记和 OSImage 标记都存在，则仿真程序根据 OSimage 标记的值冷启动，并在退出时启用保存状态，将状态保存到指定的文件名。

  • 如果 SaveState 标记存在但 OSImage 标记不存在，则仿真程序将从指定的保存状态文件还原。在仿真程序退出时，它会通过保存新的状态来覆盖已保存状态文件。

    注意 注意：

    在本示例中，SaveState 标记被注释掉，因为 .decfg 文件不能同时指定 SaveState 和 defaultsave 标记。

<DefaultSave Reconfigurable="false">true</DefaultSave>

当该值为 true 时，设备仿真程序使用 VMID 作为已保存状态文件的名称，并将已保存状态文件放置到每个用户的目录中。可以为 true 或 false。

注意 注意：

在同一个 .decfg 文件中，不能同时指定 SaveState 标记和 defaultsave 标记。

<Zoom Reconfigurable="true">true</Zoom>

将显示窗口（外观和 LCD 窗口）放大为正常大小的 2 倍。可以为 true 或 false。

<Video Reconfigurable="false" Width="640" Height="480" BitsPerPixel="16"/>

指定 LCD 窗口的屏幕大小和位深度，其中，width、height 和 BitsPerPixel 属性为整数。

注意 注意：

在同一个 .decfg 文件中，不能同时指定 Skin 和 Video 标记。

<FuncKey Reconfigurable="true">193</FuncKey>

这是一个特殊标记，其值通常为 193。值 193 会将键盘功能键（F1、F2 等）映射到设备仿真程序的软键。

<!--<Skin Reconfigurable="true" EnableSkin="true" ToolTips="on">c:\Program Files\Windows Mobile 5.0 SDK R2\PocketPC\Deviceemulation\Pocket_pc\Pocket_PC.xml</Skin>-->

加载指定的外观文件。

注意 注意：

在本示例中，Skin 标记被注释掉，因为 .decfg 文件不能同时指定 Skin 和 Video 标记。

<Board> tag

包含下列标记：

  • OSImage

  • Flash

  • MemSize

  • CpuCore

  • CpuOptions

  • VFP

<OSImage Reconfigurable="false" Address="0">d:\Program Files\Windows Mobile 5.0 SDK R2\PocketPC\Deviceemulation\0409\PPC_USA.BIN</OSImage>

指定仿真程序所使用的 OSimage 的路径和文件名（*.bin 或 *.nb0）。除非 SaveState 标记存在，否则此标记是必需的。

<Flash Reconfigurable="false" Enabled="true">c:\flash.txt</Flash>

启用闪存仿真，其中，值指定要用作闪存存储的文件的名称。

<MemSize Reconfigurable="false">256</MemSize>

设置所仿真的 RAM 大小，其中，值以 MB 为单位。有效值为从 64 到 256（含）。如果未指定有效值，则 RAM 大小默认为 64。

<CpuCore Reconfigurable="false">ARMv5</CpuCore>

指定要仿真的 CPU 体系结构。可以为 ARMv4 或 ARMv5。默认为 ARMv4。

<CpuOptions Reconfigurable="false">TDI</CpuOptions>

指定 (T)humb、(D)ebug、(I)nternetworking、(M)Long Multiply、(e)DSP 的组合。在这些选项中，总是会设置 T、D 和 I。

<VFP Reconfigurable="false">true</VFP>

指定是否存在向量浮点协处理器。可以为 true 或 false。默认为 false。

<Peripherals> tag

包含下列标记：

  • Battery

  • SharedFolder

  • CS8900_Networking

  • NE2000_Networking

  • HostOnly

  • Speakerphone

  • SerialPort

<Battery Reconfigurable="true" IsOnAcPower="false" Charge="40"/>

指定电池电源和电量。IsOnAcPower 属性指定仿真程序是使用电池还是使用交流电源运行。如果使用电池电源，则 charge 属性以百分比形式指定电量。默认为交流电源。

<SharedFolder Reconfigurable="true">c:\</SharedFolder>

将一个目录作为共享文件夹装入，其中，值为 Windows 目录。该目录就像存储卡一样装入。

<CS8900_Networking Reconfigurable="false" Enabled="true">00001A1A190B</CS8900_Networking>

启用 CS8900 网络适配器，其中，可选值是一个十二位的十六进制 MAC 地址，该地址指定桌面计算机上要绑定到的主机适配器。

<NE2000_Networking Reconfigurable="true" Enable="true">00001A1A190B</NE2000_Networking>

启用 NE2000 PCMCIA 网络适配器，其中，可选值是一个十二位的十六进制 MAC 地址，该地址指定桌面计算机上要绑定到的主机适配器。

<HostOnly Reconfigurable="true">true</HostOnly>

为网络数据包设置仅主机路由。影响 CS8900 和 NE2000 网卡。可以为 true 或 false。默认为 false。

<Speakerphone Reconfigurable="true" CarKit="true" Headset="true" Speakerphone="true"/>

  • 指定是否存在话筒、耳机和/或车载。

<SerialPort Reconfigurable="true" UARTNumber="0">COM3</SerialPort>

<SerialPort Reconfigurable="true" UARTNumber="1">COM2</SerialPort>

<SerialPort Reconfigurable="true" UARTNumber="2">none</SerialPort>

将仿真程序串行端口映射到 Windows COM 端口。UARTNumber 属性指示仿真程序上的端口号 0 到 2。该值指定桌面计算机上的 COM 端口。此标记在一个 .decfg 文件中最多可以使用三次；每次用于仿真程序上的三个串行端口中的一个。

Reconfigurable="true"

指示只要设备仿真程序正在运行，就可以重新配置与此标记相关联的功能。该功能无需退出并重新启动仿真程序即可重新配置。下列标记可重新配置：

  • AlwaysOnTop

  • HostKey

  • Rotation

  • VMName

  • Zoom

  • FuncKey

  • Skin

  • Battery

  • SharedFolder

  • NE2000_Networking

  • HostOnly

  • Speakerphone

  • Serialport

Reconfigurable="false"

指示只要设备仿真程序正在运行，就不能重新配置与此标记相关联的功能。该功能必须在仿真程序启动过程中指定。下列标记不能重新配置：

  • Language

  • ConsoleWindow

  • VMID

  • SaveState

  • DefaultSave

  • Video

  • OSImage

  • Flash

  • MemSize

  • CpuCore

  • CpuOptions

  • VFP

  • CS8900_Networking

请参见

概念

设备仿真程序配置文件
设备仿真程序管理器
设备仿真程序命令行参考


设备仿真器管理器的自动化接口

[image]

设备仿真程序
设备仿真器管理器的自动化接口
请参见

设备仿真器管理器 (DEM) 的自动化接口可提供对设备仿真器管理器中各项功能的编程访问。通过使用这些接口，可以用编程方式枚举、启动、关闭计算机上的设备仿真程序以及将它们插入底座和移除底座。这些接口通常由需要对大量仿真程序自动执行测试的质量保证 (QA) 团队使用。

设备仿真器管理器的自动化接口适用于 Visual C++ 项目以及类似于 Visual Basic Scripting Edition (VBScript) 的基于组件的脚本语言。Device Emulator samples（设备仿真程序示例）包含 Visual C++ 和 VBScript 示例。

下表显示了设备仿真器管理器的自动化接口。

编程元素 | 说明
如何：创建使用设备仿真器管理器自动化接口的项目 | 描述如何使用自动化接口创建 Visual C++ 控制台应用程序并将其设置为启动设备仿真器管理器。
IDeviceEmulatorManager | 设备仿真器管理器的顶级自动化接口。此接口表示设备仿真器管理器 (DEM) 中的根级节点，例如“数据存储”、“我的设备仿真程序”、“所有设备仿真程序”和“其他”。
IEnumManagerSDKs | 表示设备仿真器管理器 (DEM) 中的平台级节点，例如“Pocket PC 2003”或“Windows Mobile 5.0 Smartphone”。
IEnumVMIDs | 表示属于同一 SDK/平台的仿真程序的列表。
IDeviceEmulatorManagerVMID | 表示“设备仿真器管理器”窗口中的仿真程序。
EMULATOR_STATE | 一个表示仿真程序当前状态的枚举。

请参见

概念

VBScript 用户指南
如何：启动设备仿真程序管理器

其他资源

Device Emulator samples（设备仿真程序示例）


如何：创建使用设备仿真器管理器自动化接口的项目

[image]

设备仿真程序
如何：创建使用设备仿真器管理器自动化接口的项目
请参见

使用下列步骤可以创建以编程方式启动并控制设备仿真器管理器 (DEM) 的 Visual C++ Win32 控制台应用程序。该应用程序通过使用 DEM 自动化接口来控制 DEM。

通过使用这些接口，可以用编程方式枚举、启动、关闭计算机上的设备仿真程序以及将它们插入底座和移除底座。这些接口通常由需要对大量仿真程序自动执行测试的质量保证 (QA) 团队使用。

创建使用设备仿真器管理器自动化接口的项目

  1. 创建一个 Visual C++ Win32 控制台项目。

    1. 启动 Visual Studio

    2. 在“文件”菜单上，指向“新建”，然后单击“项目”。

      将出现“新建项目”对话框。

    3. 展开“Visual C++”，然后单击“Win32”。

    4. 在“模板”窗格中单击“Win32 控制台应用程序”，将项目命名为 DEMSample，然后单击“确定”。

      将出现“Win32 应用程序向导”。

    5. 单击“下一步”。

    6. 在“应用程序设置”页选中“ATL”，然后单击“完成”。

      随即将创建新项目，并将其显示在“解决方案资源管理器”中。

  2. 将 Microsoft Device Emulator 添加到项目的包含目录中。

    1. 在“解决方案资源管理器”中右击“DEMSample”，再单击“属性”。

      将出现“DEMSample 属性页”对话框。

    2. 展开“配置属性”，然后单击“C/C++”。

    3. 在“附加包含目录”旁边，添加 Microsoft Device Emulator 的文件夹，然后单击“确定”。

      默认位置为 驱动器:\program files\Microsoft Device Emulator\1.0。

  3. 导入导入自动化接口。

    1. 在“解决方案资源管理器”中双击“stdafx.h”，以便在代码编辑器中将其打开。

    2. 将下面的代码添加到该文件的末尾：

      “复制”图像 复制代码
      #import "DEMComInterface.tlb" no_namespace raw_interfaces_only

  4. 使用应用程序 Main 方法中的 IDeviceEmulatorManager。

    1. 在“解决方案资源管理器”中双击“DEMSample.cpp”，以便在代码编辑器中将其打开。

    2. 在 Main 方法中的 return 0; 的紧上方添加以下代码：

      “复制”图像 复制代码
          if (SUCCEEDED(CoInitializeEx(NULL, COINIT_MULTITHREADED)))
    {
        HRESULT hr;

        // Instantiate DeviceEmulatorManager (DEM) object.
        //  This starts DvcEmuManager.exe in silent mode.
        CComPtr<IDeviceEmulatorManager> pDeviceEmulatorManager;
        hr = pDeviceEmulatorManager.CoCreateInstance(__uuidof(DeviceEmulatorManager));

        if (FAILED(hr)) {
            wprintf_s(L"Error: Unable to instantiate DeviceEmulatorManager. ErrorCode=0x%08X\n", hr);
            system("pause");
            return -1;
        }

        hr = pDeviceEmulatorManager->ShowManagerUI(true);

        system("pause");
    }

  5. 在“调试”菜单上单击“启动调试”。

    该程序会启动设备仿真器管理器并调用 IDeviceEmulatorManager::ShowManagerUI，以使其可见。

请参见

概念

设备仿真程序

其他资源

Device Emulator（设备仿真程序）


IDeviceEmulatorManager

[image]

设备仿真程序
IDeviceEmulatorManager
示例 请参见

此接口表示设备仿真器管理器。该对象用于控制“设备仿真器管理器”窗口以及循环访问设备仿真器管理器 (DEM) 中的根级节点，例如“数据存储”、“我的设备仿真程序”、“所有设备仿真程序”和“其他”。

interface IDeviceEmulatorManager : IDispatch ();

方法

方法 | 说明
IDeviceEmulatorManager::EnumerateSDKs | 枚举当前节点中的平台。
IDeviceEmulatorManager::ShowManagerUI | 显示或隐藏“设备仿真器管理器”窗口
IDeviceEmulatorManager::MoveNext | 移至下一个节点。
IDeviceEmulatorManager::Reset | 移回第一个节点（通常为“数据存储”）。
IDeviceEmulatorManager::Refresh | 通过重新读取“数据存储”中的信息刷新枚举。
IDeviceEmulatorManager::get_Name | 获取当前节点的名称，例如“数据存储”、“我的设备仿真程序”、“所有设备仿真程序”或“其他”。
IDeviceEmulatorManager::RegisterRefreshEvent | 注册设备仿真器管理器的刷新事件。
IDeviceEmulatorManager::UnRegisterRefreshEvent | 取消对刷新事件的注册。

备注

若要创建实现此接口的对象，请使用 CoCreateInstance。

实现此接口的对象是一个链接列表，其中包含 DEM 窗口中的所有根级节点。

示例

下面的示例将列出“设备仿真器管理器”窗口中的节点、SDK/平台和仿真程序。

“复制”图像 复制代码
int _tmain(int argc, _TCHAR* argv[])
{
    if (SUCCEEDED(CoInitializeEx(NULL, COINIT_MULTITHREADED)))
    {
        // HRESULT is used to determine whether method calls are successful
        HRESULT hr;

        // Instantiate DeviceEmulatorManager (DEM) object.
        // This starts DvcEmuManager.exe in silent mode

        CComPtr<IDeviceEmulatorManager> pDeviceEmulatorManager;
        hr = pDeviceEmulatorManager.CoCreateInstance(__uuidof(DeviceEmulatorManager));
        if (FAILED(hr)) {
            wprintf_s(L"Error: Unable to instantiate DeviceEmulatorManager. ErrorCode=0x%08X\n", hr);
            return false;
        }

        // For each of the four nodes in the Device Emulator Manager window
        // (Datastore, My Device Emulators, All Device Emulators, and Others)
        for (; SUCCEEDED(hr); (hr = pDeviceEmulatorManager->MoveNext()))
        {
            CComPtr<IEnumManagerSDKs> pSDKEnumerator;
            CComBSTR node;

            // Output the name of node
            hr = pDeviceEmulatorManager->get_Name(&node);
            if (FAILED(hr)) {
                wprintf_s(L"Error: Failed to get current SDK category name. ErrorCode=0x%08X\n", hr);
                return false;
            }
            wprintf_s(L"- %s\n", node);

            // Get a list of SDKs/platforms in this node
            hr = pDeviceEmulatorManager->EnumerateSDKs(&pSDKEnumerator);
            if (FAILED(hr)) {
                wprintf_s(L"Error: Failed to get enumerator for the SDK Category[%s]. ErrorCode=0x%08X\n", node, hr);
                return false;
            }

            // For every SDK/platform in the list
            for (; SUCCEEDED(hr); (hr = pSDKEnumerator->MoveNext()))
            {
                CComBSTR sdkName;

                // Output its name
                hr = pSDKEnumerator->get_Name(&sdkName);
                if (hr == E_ENUMSDK_NOT_LOADED ) {
                    continue;
                } else if (FAILED(hr)) {
                    wprintf_s(L"Error: Failed to get SDK details. ErrorCode=0x%08X\n", hr);
                    return false;
                }
                wprintf_s(L"\t- %s\n", sdkName);

                // Get the list of emulators in the SDK/platform
                CComPtr<IEnumVMIDs> pDeviceEnumerator;
                hr = pSDKEnumerator->EnumerateVMIDs(&pDeviceEnumerator);
                if (FAILED(hr)) {
                    wprintf_s(L"Error: Failed to get enumerator for VM devices. ErrorCode=0x%08X\n", hr);
                    return false;
                }

                // For every emulator in the list
                for (; SUCCEEDED(hr); (hr = pDeviceEnumerator->MoveNext()))
                {
                    CComBSTR deviceName;
                    CComPtr<IDeviceEmulatorManagerVMID> pDevice;

                    // Get the IDeviceEmulatorManagerVMID object.
                    hr = pDeviceEnumerator->GetVMID(&pDevice);
                    if (FAILED(hr)) {
                        continue;
                    }

                    // Output the name of the emulator.
                    hr = pDevice->get_Name(&deviceName);
                    if (FAILED(hr)){
                        continue;
                    }
                    wprintf_s(L"\t\t%s\n", deviceName);
                }
            }
        }
        return true;
        CoUninitialize();
    }
    return false;
}

要求

DEMComInterface.tlb

请参见

其他资源

Device Emulator samples（设备仿真程序示例）


IDeviceEmulatorManager::EnumerateSDKs

[image]

设备仿真程序
IDeviceEmulatorManager::EnumerateSDKs
示例

枚举当前节点中的平台。

HRESULT EnumerateSDKs([out,retval] IEnumManagerSDKs** ppEnumManagerSDKs);

参数

[out,retval] ppEnumManagerSDKs

一个指针，它指向实现 IEnumManagerSDKs 的对象。该对象是当前节点中的平台的列表。

返回值

一个指示方法调用结果的 HRESULT 值。

示例

下面的示例将列出“设备仿真器管理器”窗口中的节点、SDK/平台和仿真程序。

“复制”图像 复制代码
int _tmain(int argc, _TCHAR* argv[])
{
    if (SUCCEEDED(CoInitializeEx(NULL, COINIT_MULTITHREADED)))
    {
        // HRESULT is used to determine whether method calls are successful
        HRESULT hr;

        // Instantiate DeviceEmulatorManager (DEM) object.
        // This starts DvcEmuManager.exe in silent mode

        CComPtr<IDeviceEmulatorManager> pDeviceEmulatorManager;
        hr = pDeviceEmulatorManager.CoCreateInstance(__uuidof(DeviceEmulatorManager));
        if (FAILED(hr)) {
            wprintf_s(L"Error: Unable to instantiate DeviceEmulatorManager. ErrorCode=0x%08X\n", hr);
            return false;
        }

        // For each of the four nodes in the Device Emulator Manager window
        // (Datastore, My Device Emulators, All Device Emulators, and Others)
        for (; SUCCEEDED(hr); (hr = pDeviceEmulatorManager->MoveNext()))
        {
            CComPtr<IEnumManagerSDKs> pSDKEnumerator;
            CComBSTR node;

            // Output the name of node
            hr = pDeviceEmulatorManager->get_Name(&node);
            if (FAILED(hr)) {
                wprintf_s(L"Error: Failed to get current SDK category name. ErrorCode=0x%08X\n", hr);
                return false;
            }
            wprintf_s(L"- %s\n", node);

            // Get a list of SDKs/platforms in this node
            hr = pDeviceEmulatorManager->EnumerateSDKs(&pSDKEnumerator);
            if (FAILED(hr)) {
                wprintf_s(L"Error: Failed to get enumerator for the SDK Category[%s]. ErrorCode=0x%08X\n", node, hr);
                return false;
            }

            // For every SDK/platform in the list
            for (; SUCCEEDED(hr); (hr = pSDKEnumerator->MoveNext()))
            {
                CComBSTR sdkName;

                // Output its name
                hr = pSDKEnumerator->get_Name(&sdkName);
                if (hr == E_ENUMSDK_NOT_LOADED ) {
                    continue;
                } else if (FAILED(hr)) {
                    wprintf_s(L"Error: Failed to get SDK details. ErrorCode=0x%08X\n", hr);
                    return false;
                }
                wprintf_s(L"\t- %s\n", sdkName);

                // Get the list of emulators in the SDK/platform
                CComPtr<IEnumVMIDs> pDeviceEnumerator;
                hr = pSDKEnumerator->EnumerateVMIDs(&pDeviceEnumerator);
                if (FAILED(hr)) {
                    wprintf_s(L"Error: Failed to get enumerator for VM devices. ErrorCode=0x%08X\n", hr);
                    return false;
                }

                // For every emulator in the list
                for (; SUCCEEDED(hr); (hr = pDeviceEnumerator->MoveNext()))
                {
                    CComBSTR deviceName;
                    CComPtr<IDeviceEmulatorManagerVMID> pDevice;

                    // Get the IDeviceEmulatorManagerVMID object.
                    hr = pDeviceEnumerator->GetVMID(&pDevice);
                    if (FAILED(hr)) {
                        continue;
                    }

                    // Output the name of the emulator.
                    hr = pDevice->get_Name(&deviceName);
                    if (FAILED(hr)){
                        continue;
                    }
                    wprintf_s(L"\t\t%s\n", deviceName);
                }
            }
        }
        return true;
        CoUninitialize();
    }
    return false;
}

要求

DEMComInterface.tlb


IDeviceEmulatorManager::ShowManagerUI

[image]

设备仿真程序
IDeviceEmulatorManager::ShowManagerUI
示例

显示或隐藏“设备仿真器管理器”窗口。

HRESULT ShowManagerUI([in] BOOL fShow);

参数

[in] fShow

指示是显示还是隐藏“设备仿真器管理器”窗口。使用 true 可显示该窗口，使用 false 可隐藏该窗口。

返回值

一个指示方法调用结果的 HRESULT 值。

示例

“复制”图像 复制代码
// Start the Device Emulator Manager.
CComPtr<IDeviceEmulatorManager> pDeviceEmulatorManager;
pDeviceEmulatorManager.CoCreateInstance(__uuidof(DeviceEmulatorManager));

// Show the window.
pDeviceEmulatorManager->ShowManagerUI(true);

// Hide the window.
pDeviceEmulatorManager->ShowManagerUI(false);

要求

DEMComInterface.tlb


IDeviceEmulatorManager::MoveNext

[image]

设备仿真程序
IDeviceEmulatorManager::MoveNext
示例

移至列表中的下一个节点。

HRESULT MoveNext();

返回值

一个指示方法调用结果的 HRESULT 值。

此方法将返回一个 HRESULT 值，如果当前平台是对象中的最后一个节点，该值则表示失败。

示例

下面的示例将列出“设备仿真器管理器”窗口中的节点、SDK/平台和仿真程序。

“复制”图像 复制代码
int _tmain(int argc, _TCHAR* argv[])
{
    if (SUCCEEDED(CoInitializeEx(NULL, COINIT_MULTITHREADED)))
    {
        // HRESULT is used to determine whether method calls are successful
        HRESULT hr;

        // Instantiate DeviceEmulatorManager (DEM) object.
        // This starts DvcEmuManager.exe in silent mode

        CComPtr<IDeviceEmulatorManager> pDeviceEmulatorManager;
        hr = pDeviceEmulatorManager.CoCreateInstance(__uuidof(DeviceEmulatorManager));
        if (FAILED(hr)) {
            wprintf_s(L"Error: Unable to instantiate DeviceEmulatorManager. ErrorCode=0x%08X\n", hr);
            return false;
        }

        // For each of the four nodes in the Device Emulator Manager window
        // (Datastore, My Device Emulators, All Device Emulators, and Others)
        for (; SUCCEEDED(hr); (hr = pDeviceEmulatorManager->MoveNext()))
        {
            CComPtr<IEnumManagerSDKs> pSDKEnumerator;
            CComBSTR node;

            // Output the name of node
            hr = pDeviceEmulatorManager->get_Name(&node);
            if (FAILED(hr)) {
                wprintf_s(L"Error: Failed to get current SDK category name. ErrorCode=0x%08X\n", hr);
                return false;
            }
            wprintf_s(L"- %s\n", node);

            // Get a list of SDKs/platforms in this node
            hr = pDeviceEmulatorManager->EnumerateSDKs(&pSDKEnumerator);
            if (FAILED(hr)) {
                wprintf_s(L"Error: Failed to get enumerator for the SDK Category[%s]. ErrorCode=0x%08X\n", node, hr);
                return false;
            }

            // For every SDK/platform in the list
            for (; SUCCEEDED(hr); (hr = pSDKEnumerator->MoveNext()))
            {
                CComBSTR sdkName;

                // Output its name
                hr = pSDKEnumerator->get_Name(&sdkName);
                if (hr == E_ENUMSDK_NOT_LOADED ) {
                    continue;
                } else if (FAILED(hr)) {
                    wprintf_s(L"Error: Failed to get SDK details. ErrorCode=0x%08X\n", hr);
                    return false;
                }
                wprintf_s(L"\t- %s\n", sdkName);

                // Get the list of emulators in the SDK/platform
                CComPtr<IEnumVMIDs> pDeviceEnumerator;
                hr = pSDKEnumerator->EnumerateVMIDs(&pDeviceEnumerator);
                if (FAILED(hr)) {
                    wprintf_s(L"Error: Failed to get enumerator for VM devices. ErrorCode=0x%08X\n", hr);
                    return false;
                }

                // For every emulator in the list
                for (; SUCCEEDED(hr); (hr = pDeviceEnumerator->MoveNext()))
                {
                    CComBSTR deviceName;
                    CComPtr<IDeviceEmulatorManagerVMID> pDevice;

                    // Get the IDeviceEmulatorManagerVMID object.
                    hr = pDeviceEnumerator->GetVMID(&pDevice);
                    if (FAILED(hr)) {
                        continue;
                    }

                    // Output the name of the emulator.
                    hr = pDevice->get_Name(&deviceName);
                    if (FAILED(hr)){
                        continue;
                    }
                    wprintf_s(L"\t\t%s\n", deviceName);
                }
            }
        }
        return true;
        CoUninitialize();
    }
    return false;
}

要求

DEMComInterface.tlb


IDeviceEmulatorManager::Reset

[image]

设备仿真程序
IDeviceEmulatorManager::Reset

将内部迭代器移回第一个节点（通常为“数据存储”）。

HRESULT Reset();

返回值

一个指示方法调用结果的 HRESULT 值。

要求

DEMComInterface.tlb


IDeviceEmulatorManager::Refresh

[image]

设备仿真程序
IDeviceEmulatorManager::Refresh

通过重新读取“数据存储”中的信息刷新枚举。

HRESULT Refresh();

返回值

一个指示方法调用结果的 HRESULT 值。

备注

此方法等同于单击“设备仿真器管理器”窗口中的“刷新”。

要求

DEMComInterface.tlb


IDeviceEmulatorManager::get_Name

[image]

设备仿真程序
IDeviceEmulatorManager::get_Name
示例

获取当前节点的名称，例如“我的设备仿真程序”、“所有设备仿真程序”或“其他”。

HRESULT get_Name([out, retval] BSTR* pbstrName);

参数

[out] pbstrName

一个指针，它指向在方法调用后用当前节点的名称填充的 BSTR。

返回值

一个指示方法调用结果的 HRESULT 值。

示例

下面的示例将列出“设备仿真器管理器”窗口中的节点、SDK/平台和仿真程序。

“复制”图像 复制代码
int _tmain(int argc, _TCHAR* argv[])
{
    if (SUCCEEDED(CoInitializeEx(NULL, COINIT_MULTITHREADED)))
    {
        // HRESULT is used to determine whether method calls are successful
        HRESULT hr;

        // Instantiate DeviceEmulatorManager (DEM) object.
        // This starts DvcEmuManager.exe in silent mode

        CComPtr<IDeviceEmulatorManager> pDeviceEmulatorManager;
        hr = pDeviceEmulatorManager.CoCreateInstance(__uuidof(DeviceEmulatorManager));
        if (FAILED(hr)) {
            wprintf_s(L"Error: Unable to instantiate DeviceEmulatorManager. ErrorCode=0x%08X\n", hr);
            return false;
        }

        // For each of the four nodes in the Device Emulator Manager window
        // (Datastore, My Device Emulators, All Device Emulators, and Others)
        for (; SUCCEEDED(hr); (hr = pDeviceEmulatorManager->MoveNext()))
        {
            CComPtr<IEnumManagerSDKs> pSDKEnumerator;
            CComBSTR node;

            // Output the name of node
            hr = pDeviceEmulatorManager->get_Name(&node);
            if (FAILED(hr)) {
                wprintf_s(L"Error: Failed to get current SDK category name. ErrorCode=0x%08X\n", hr);
                return false;
            }
            wprintf_s(L"- %s\n", node);

            // Get a list of SDKs/platforms in this node
            hr = pDeviceEmulatorManager->EnumerateSDKs(&pSDKEnumerator);
            if (FAILED(hr)) {
                wprintf_s(L"Error: Failed to get enumerator for the SDK Category[%s]. ErrorCode=0x%08X\n", node, hr);
                return false;
            }

            // For every SDK/platform in the list
            for (; SUCCEEDED(hr); (hr = pSDKEnumerator->MoveNext()))
            {
                CComBSTR sdkName;

                // Output its name
                hr = pSDKEnumerator->get_Name(&sdkName);
                if (hr == E_ENUMSDK_NOT_LOADED ) {
                    continue;
                } else if (FAILED(hr)) {
                    wprintf_s(L"Error: Failed to get SDK details. ErrorCode=0x%08X\n", hr);
                    return false;
                }
                wprintf_s(L"\t- %s\n", sdkName);

                // Get the list of emulators in the SDK/platform
                CComPtr<IEnumVMIDs> pDeviceEnumerator;
                hr = pSDKEnumerator->EnumerateVMIDs(&pDeviceEnumerator);
                if (FAILED(hr)) {
                    wprintf_s(L"Error: Failed to get enumerator for VM devices. ErrorCode=0x%08X\n", hr);
                    return false;
                }

                // For every emulator in the list
                for (; SUCCEEDED(hr); (hr = pDeviceEnumerator->MoveNext()))
                {
                    CComBSTR deviceName;
                    CComPtr<IDeviceEmulatorManagerVMID> pDevice;

                    // Get the IDeviceEmulatorManagerVMID object.
                    hr = pDeviceEnumerator->GetVMID(&pDevice);
                    if (FAILED(hr)) {
                        continue;
                    }

                    // Output the name of the emulator.
                    hr = pDevice->get_Name(&deviceName);
                    if (FAILED(hr)){
                        continue;
                    }
                    wprintf_s(L"\t\t%s\n", deviceName);
                }
            }
        }
        return true;
        CoUninitialize();
    }
    return false;
}

要求

DEMComInterface.tlb


IDeviceEmulatorManager::RegisterRefreshEvent

[image]

设备仿真程序
IDeviceEmulatorManager::RegisterRefreshEvent
示例 请参见

注册事件，接收当由于“数据存储”区域、“我的设备仿真程序”文件夹或“所有设备仿真程序”文件夹中发生变化而必须刷新 IDeviceEmulatorManager 时发出的通知。

HRESULT RegisterRefreshEvent(BSTR bstrEventName);

参数

bstrEventName

要注册的名称。

返回值

一个指示方法调用结果的 HRESULT 值。

异常

异常 | 说明
S_FALSE | 指定的事件已注册。
E_INVALIDARG | 指定的事件为 NULL。
任何其他失败情况 | OpenEvent（当指定的事件失败时）。若要获取扩展的错误信息，请调用 GetLastError。

备注

“设备仿真器管理器”窗口中的节点发生更改时将激发事件。当修改“我的设备仿真程序”或“所有设备仿真程序”文件夹中的设备仿真程序配置文件时，或安装新的仿真程序 OS 映像时，这些节点会发生更改。程序应在接到通知后调用 IDeviceEmulatorManager::Refresh 以保持最新。

示例

此代码示例在后台启动设备仿真程序管理器 (DEM)，注册用于接收 DEM 刷新通知的事件，并等待 60 秒以发生刷新事件。

“复制”图像 复制代码
#include "stdafx.h"

// Function declarations
DWORD WINAPI workerThread(HANDLE);
void UnRegisterRefreshEvent();
HANDLE RegisterRefreshEvent(BSTR);

// Global DEM COM pointer object
CComPtr<IDeviceEmulatorManager> pDeviceEmulatorManager;

int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
{
    int nRetCode = 0;
    HRESULT hr;

    // Name of Event
    BSTR Named_Event = L"__MyEvent1";

    // Start Device Emulator Manager (DEM)
    CoInitialize(NULL);
    hr = pDeviceEmulatorManager.CoCreateInstance(__uuidof(DeviceEmulatorManager));
    if (FAILED(hr))
    {
        wprintf(L"Error: Unable to instantiate DeviceEmulatorManager. ErrorCode=0x%08X\n", hr);
        nRetCode = -1;
    }

    // Register DEM Refresh Event
    HANDLE Named_Handle = RegisterRefreshEvent(Named_Event);

    // Create a worker thread to wait for Refresh Event
    HANDLE h = CreateThread(NULL, 0, workerThread, (HANDLE) Named_Handle, 0, NULL);
    if (h == NULL)
    {
         // Not Able to create worker Thread.
         // Add code to handle error.
    }

    //
    //
    // Add code to perform program's main functions here.
    //
    system("pause");
    //
    // Wait for the worker thread to complete (or post a message to workerthread
    // to terminate)
    //

    //  Finally UnRegister the DEM Refresh Event
    UnRegisterRefreshEvent();

    // Close all handles
    CloseHandle(h);
    CloseHandle(Named_Handle);

    // Uninitialize DEM
    CoUninitialize ();

    return nRetCode;
}

HANDLE RegisterRefreshEvent(BSTR Named_Event)
{
    HRESULT hr;
    // Create the Event Handle for the Named Event you are interested
    HANDLE Named_EventHandle = CreateEvent( (LPSECURITY_ATTRIBUTES)0, false, false, Named_Event);
    if (Named_EventHandle == NULL)
    {
         // Not Able to create the Named Event.
         // Add code to handle error.
    }

    // Register for the refresh event.
    hr = pDeviceEmulatorManager->RegisterRefreshEvent(Named_Event);
    // Add code to handle possible errors.

    return Named_EventHandle;
}

void UnRegisterRefreshEvent()
{
    // UnRegister the refresh event.
    pDeviceEmulatorManager->UnRegisterRefreshEvent();
    // Add code to handle possible errors.
}

DWORD WINAPI workerThread(HANDLE Named_Handle)
{
    HRESULT hr;
    int Infinite = 0;
    int WAIT_Timeout = 0X00000102;

    // Timeout after 60 seconds.
    int MY_TIMEOUT =60*1000;

    // Block the worker thread until event is signaled or timeout occurs.
    // Named_Handle has been registered to fire when there is a change in the DataStore,
    // the My Device Emulators, or the All Device Emulators folder.
    int ret = WaitForSingleObject(Named_Handle, MY_TIMEOUT );
    if(ret == 0)
    {
        // The event Event was signled. Refresh DEM
        hr = pDeviceEmulatorManager->Refresh();
        wprintf(L"Refreshing the Device Emulator Manager");
    }
    else if(ret == WAIT_Timeout )
    {
        // Event was not signled in timeout period
        wprintf(L"Worker Thread Timeout. No refresh required.");
    }
    else
    {
        // Unknown Error
    }
    return 0;
}

要求

DEMComInterface.tlb

请参见

概念

IDeviceEmulatorManager


IDeviceEmulatorManager::UnRegisterRefreshEvent

[image]

设备仿真程序
IDeviceEmulatorManager::UnRegisterRefreshEvent
示例 请参见

取消对刷新事件的注册。

HRESULT UnRegisterRefreshEvent();

返回值

一个指示方法调用结果的 HRESULT 值。

异常

异常 | 说明
S_FALSE | 事件没有注册。

示例

此代码示例在后台启动设备仿真程序管理器 (DEM)，注册用于接收 DEM 刷新通知的事件，并等待 60 秒以发生刷新事件。

“复制”图像 复制代码
#include "stdafx.h"

// Function declarations
DWORD WINAPI workerThread(HANDLE);
void UnRegisterRefreshEvent();
HANDLE RegisterRefreshEvent(BSTR);

// Global DEM COM pointer object
CComPtr<IDeviceEmulatorManager> pDeviceEmulatorManager;

int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
{
    int nRetCode = 0;
    HRESULT hr;

    // Name of Event
    BSTR Named_Event = L"__MyEvent1";

    // Start Device Emulator Manager (DEM)
    CoInitialize(NULL);
    hr = pDeviceEmulatorManager.CoCreateInstance(__uuidof(DeviceEmulatorManager));
    if (FAILED(hr))
    {
        wprintf(L"Error: Unable to instantiate DeviceEmulatorManager. ErrorCode=0x%08X\n", hr);
        nRetCode = -1;
    }

    // Register DEM Refresh Event
    HANDLE Named_Handle = RegisterRefreshEvent(Named_Event);

    // Create a worker thread to wait for Refresh Event
    HANDLE h = CreateThread(NULL, 0, workerThread, (HANDLE) Named_Handle, 0, NULL);
    if (h == NULL)
    {
         // Not Able to create worker Thread.
         // Add code to handle error.
    }

    //
    //
    // Add code to perform program's main functions here.
    //
    system("pause");
    //
    // Wait for the worker thread to complete (or post a message to workerthread
    // to terminate)
    //

    //  Finally UnRegister the DEM Refresh Event
    UnRegisterRefreshEvent();

    // Close all handles
    CloseHandle(h);
    CloseHandle(Named_Handle);

    // Uninitialize DEM
    CoUninitialize ();

    return nRetCode;
}

HANDLE RegisterRefreshEvent(BSTR Named_Event)
{
    HRESULT hr;
    // Create the Event Handle for the Named Event you are interested
    HANDLE Named_EventHandle = CreateEvent( (LPSECURITY_ATTRIBUTES)0, false, false, Named_Event);
    if (Named_EventHandle == NULL)
    {
         // Not Able to create the Named Event.
         // Add code to handle error.
    }

    // Register for the refresh event.
    hr = pDeviceEmulatorManager->RegisterRefreshEvent(Named_Event);
    // Add code to handle possible errors.

    return Named_EventHandle;
}

void UnRegisterRefreshEvent()
{
    // UnRegister the refresh event.
    pDeviceEmulatorManager->UnRegisterRefreshEvent();
    // Add code to handle possible errors.
}

DWORD WINAPI workerThread(HANDLE Named_Handle)
{
    HRESULT hr;
    int Infinite = 0;
    int WAIT_Timeout = 0X00000102;

    // Timeout after 60 seconds.
    int MY_TIMEOUT =60*1000;

    // Block the worker thread until event is signaled or timeout occurs.
    // Named_Handle has been registered to fire when there is a change in the DataStore,
    // the My Device Emulators, or the All Device Emulators folder.
    int ret = WaitForSingleObject(Named_Handle, MY_TIMEOUT );
    if(ret == 0)
    {
        // The event Event was signled. Refresh DEM
        hr = pDeviceEmulatorManager->Refresh();
        wprintf(L"Refreshing the Device Emulator Manager");
    }
    else if(ret == WAIT_Timeout )
    {
        // Event was not signled in timeout period
        wprintf(L"Worker Thread Timeout. No refresh required.");
    }
    else
    {
        // Unknown Error
    }
    return 0;
}

要求

DEMComInterface.tlb

请参见

概念

IDeviceEmulatorManager


IEnumManagerSDKs

[image]

设备仿真程序
IEnumManagerSDKs
示例 请参见

此接口表示设备仿真器管理器 (DEM) 中的平台级节点，例如“Pocket PC 2003”或“Windows Mobile 5.0 Smartphone”。

interface IEnumManagerSDKs : IDispatch {}

方法

方法 | 说明
IEnumManagerSDKs::EnumerateVMIDs | 枚举属于当前平台的仿真程序。
IEnumManagerSDKs::MoveNext | 移至下一个平台。
IEnumManagerSDKs::Reset | 移回第一个平台。
IEnumManagerSDKs::get_Name | 获取当前平台的名称。

备注

若要创建实现此接口的对象，请使用 IDeviceEmulatorManager::EnumerateSDKs。实现此接口的对象是一个链接列表，其中包含节点中的所有平台。

示例

下面的示例将列出“设备仿真器管理器”窗口中的节点、SDK/平台和仿真程序。

“复制”图像 复制代码
int _tmain(int argc, _TCHAR* argv[])
{
    if (SUCCEEDED(CoInitializeEx(NULL, COINIT_MULTITHREADED)))
    {
        // HRESULT is used to determine whether method calls are successful
        HRESULT hr;

        // Instantiate DeviceEmulatorManager (DEM) object.
        // This starts DvcEmuManager.exe in silent mode

        CComPtr<IDeviceEmulatorManager> pDeviceEmulatorManager;
        hr = pDeviceEmulatorManager.CoCreateInstance(__uuidof(DeviceEmulatorManager));
        if (FAILED(hr)) {
            wprintf_s(L"Error: Unable to instantiate DeviceEmulatorManager. ErrorCode=0x%08X\n", hr);
            return false;
        }

        // For each of the four nodes in the Device Emulator Manager window
        // (Datastore, My Device Emulators, All Device Emulators, and Others)
        for (; SUCCEEDED(hr); (hr = pDeviceEmulatorManager->MoveNext()))
        {
            CComPtr<IEnumManagerSDKs> pSDKEnumerator;
            CComBSTR node;

            // Output the name of node
            hr = pDeviceEmulatorManager->get_Name(&node);
            if (FAILED(hr)) {
                wprintf_s(L"Error: Failed to get current SDK category name. ErrorCode=0x%08X\n", hr);
                return false;
            }
            wprintf_s(L"- %s\n", node);

            // Get a list of SDKs/platforms in this node
            hr = pDeviceEmulatorManager->EnumerateSDKs(&pSDKEnumerator);
            if (FAILED(hr)) {
                wprintf_s(L"Error: Failed to get enumerator for the SDK Category[%s]. ErrorCode=0x%08X\n", node, hr);
                return false;
            }

            // For every SDK/platform in the list
            for (; SUCCEEDED(hr); (hr = pSDKEnumerator->MoveNext()))
            {
                CComBSTR sdkName;

                // Output its name
                hr = pSDKEnumerator->get_Name(&sdkName);
                if (hr == E_ENUMSDK_NOT_LOADED ) {
                    continue;
                } else if (FAILED(hr)) {
                    wprintf_s(L"Error: Failed to get SDK details. ErrorCode=0x%08X\n", hr);
                    return false;
                }
                wprintf_s(L"\t- %s\n", sdkName);

                // Get the list of emulators in the SDK/platform
                CComPtr<IEnumVMIDs> pDeviceEnumerator;
                hr = pSDKEnumerator->EnumerateVMIDs(&pDeviceEnumerator);
                if (FAILED(hr)) {
                    wprintf_s(L"Error: Failed to get enumerator for VM devices. ErrorCode=0x%08X\n", hr);
                    return false;
                }

                // For every emulator in the list
                for (; SUCCEEDED(hr); (hr = pDeviceEnumerator->MoveNext()))
                {
                    CComBSTR deviceName;
                    CComPtr<IDeviceEmulatorManagerVMID> pDevice;

                    // Get the IDeviceEmulatorManagerVMID object.
                    hr = pDeviceEnumerator->GetVMID(&pDevice);
                    if (FAILED(hr)) {
                        continue;
                    }

                    // Output the name of the emulator.
                    hr = pDevice->get_Name(&deviceName);
                    if (FAILED(hr)){
                        continue;
                    }
                    wprintf_s(L"\t\t%s\n", deviceName);
                }
            }
        }
        return true;
        CoUninitialize();
    }
    return false;
}

要求

DEMComInterface.tlb

请参见

其他资源

Device Emulator samples（设备仿真程序示例）


IEnumManagerSDKs::EnumerateVMIDs

[image]

设备仿真程序
IEnumManagerSDKs::EnumerateVMIDs
示例

枚举属于当前平台的仿真程序。

HRESULT EnumerateVMIDs([out,retval] IEnumVMIDs** ppEnumVMIDs);

参数

[out,retval] ppEnumVMIDs

一个指针，它指向实现 IEnumVMIDs 的对象。该对象是当前平台中的仿真程序的列表。

返回值

一个指示方法调用结果的 HRESULT 值。

示例

下面的示例将列出“设备仿真器管理器”窗口中的节点、SDK/平台和仿真程序。

“复制”图像 复制代码
int _tmain(int argc, _TCHAR* argv[])
{
    if (SUCCEEDED(CoInitializeEx(NULL, COINIT_MULTITHREADED)))
    {
        // HRESULT is used to determine whether method calls are successful
        HRESULT hr;

        // Instantiate DeviceEmulatorManager (DEM) object.
        // This starts DvcEmuManager.exe in silent mode

        CComPtr<IDeviceEmulatorManager> pDeviceEmulatorManager;
        hr = pDeviceEmulatorManager.CoCreateInstance(__uuidof(DeviceEmulatorManager));
        if (FAILED(hr)) {
            wprintf_s(L"Error: Unable to instantiate DeviceEmulatorManager. ErrorCode=0x%08X\n", hr);
            return false;
        }

        // For each of the four nodes in the Device Emulator Manager window
        // (Datastore, My Device Emulators, All Device Emulators, and Others)
        for (; SUCCEEDED(hr); (hr = pDeviceEmulatorManager->MoveNext()))
        {
            CComPtr<IEnumManagerSDKs> pSDKEnumerator;
            CComBSTR node;

            // Output the name of node
            hr = pDeviceEmulatorManager->get_Name(&node);
            if (FAILED(hr)) {
                wprintf_s(L"Error: Failed to get current SDK category name. ErrorCode=0x%08X\n", hr);
                return false;
            }
            wprintf_s(L"- %s\n", node);

            // Get a list of SDKs/platforms in this node
            hr = pDeviceEmulatorManager->EnumerateSDKs(&pSDKEnumerator);
            if (FAILED(hr)) {
                wprintf_s(L"Error: Failed to get enumerator for the SDK Category[%s]. ErrorCode=0x%08X\n", node, hr);
                return false;
            }

            // For every SDK/platform in the list
            for (; SUCCEEDED(hr); (hr = pSDKEnumerator->MoveNext()))
            {
                CComBSTR sdkName;

                // Output its name
                hr = pSDKEnumerator->get_Name(&sdkName);
                if (hr == E_ENUMSDK_NOT_LOADED ) {
                    continue;
                } else if (FAILED(hr)) {
                    wprintf_s(L"Error: Failed to get SDK details. ErrorCode=0x%08X\n", hr);
                    return false;
                }
                wprintf_s(L"\t- %s\n", sdkName);

                // Get the list of emulators in the SDK/platform
                CComPtr<IEnumVMIDs> pDeviceEnumerator;
                hr = pSDKEnumerator->EnumerateVMIDs(&pDeviceEnumerator);
                if (FAILED(hr)) {
                    wprintf_s(L"Error: Failed to get enumerator for VM devices. ErrorCode=0x%08X\n", hr);
                    return false;
                }

                // For every emulator in the list
                for (; SUCCEEDED(hr); (hr = pDeviceEnumerator->MoveNext()))
                {
                    CComBSTR deviceName;
                    CComPtr<IDeviceEmulatorManagerVMID> pDevice;

                    // Get the IDeviceEmulatorManagerVMID object.
                    hr = pDeviceEnumerator->GetVMID(&pDevice);
                    if (FAILED(hr)) {
                        continue;
                    }

                    // Output the name of the emulator.
                    hr = pDevice->get_Name(&deviceName);
                    if (FAILED(hr)){
                        continue;
                    }
                    wprintf_s(L"\t\t%s\n", deviceName);
                }
            }
        }
        return true;
        CoUninitialize();
    }
    return false;
}

要求

DEMComInterface.tlb


IEnumManagerSDKs::MoveNext

[image]

设备仿真程序
IEnumManagerSDKs::MoveNext
示例

移至列表中的下一个平台。

HRESULT MoveNext();

返回值

一个指示方法调用结果的 HRESULT 值。

此方法将返回一个 HRESULT 值，如果当前平台是对象中的最后一个节点，该值则表示失败。

示例

下面的示例将列出“设备仿真器管理器”窗口中的节点、SDK/平台和仿真程序。

“复制”图像 复制代码
int _tmain(int argc, _TCHAR* argv[])
{
    if (SUCCEEDED(CoInitializeEx(NULL, COINIT_MULTITHREADED)))
    {
        // HRESULT is used to determine whether method calls are successful
        HRESULT hr;

        // Instantiate DeviceEmulatorManager (DEM) object.
        // This starts DvcEmuManager.exe in silent mode

        CComPtr<IDeviceEmulatorManager> pDeviceEmulatorManager;
        hr = pDeviceEmulatorManager.CoCreateInstance(__uuidof(DeviceEmulatorManager));
        if (FAILED(hr)) {
            wprintf_s(L"Error: Unable to instantiate DeviceEmulatorManager. ErrorCode=0x%08X\n", hr);
            return false;
        }

        // For each of the four nodes in the Device Emulator Manager window
        // (Datastore, My Device Emulators, All Device Emulators, and Others)
        for (; SUCCEEDED(hr); (hr = pDeviceEmulatorManager->MoveNext()))
        {
            CComPtr<IEnumManagerSDKs> pSDKEnumerator;
            CComBSTR node;

            // Output the name of node
            hr = pDeviceEmulatorManager->get_Name(&node);
            if (FAILED(hr)) {
                wprintf_s(L"Error: Failed to get current SDK category name. ErrorCode=0x%08X\n", hr);
                return false;
            }
            wprintf_s(L"- %s\n", node);

            // Get a list of SDKs/platforms in this node
            hr = pDeviceEmulatorManager->EnumerateSDKs(&pSDKEnumerator);
            if (FAILED(hr)) {
                wprintf_s(L"Error: Failed to get enumerator for the SDK Category[%s]. ErrorCode=0x%08X\n", node, hr);
                return false;
            }

            // For every SDK/platform in the list
            for (; SUCCEEDED(hr); (hr = pSDKEnumerator->MoveNext()))
            {
                CComBSTR sdkName;

                // Output its name
                hr = pSDKEnumerator->get_Name(&sdkName);
                if (hr == E_ENUMSDK_NOT_LOADED ) {
                    continue;
                } else if (FAILED(hr)) {
                    wprintf_s(L"Error: Failed to get SDK details. ErrorCode=0x%08X\n", hr);
                    return false;
                }
                wprintf_s(L"\t- %s\n", sdkName);

                // Get the list of emulators in the SDK/platform
                CComPtr<IEnumVMIDs> pDeviceEnumerator;
                hr = pSDKEnumerator->EnumerateVMIDs(&pDeviceEnumerator);
                if (FAILED(hr)) {
                    wprintf_s(L"Error: Failed to get enumerator for VM devices. ErrorCode=0x%08X\n", hr);
                    return false;
                }

                // For every emulator in the list
                for (; SUCCEEDED(hr); (hr = pDeviceEnumerator->MoveNext()))
                {
                    CComBSTR deviceName;
                    CComPtr<IDeviceEmulatorManagerVMID> pDevice;

                    // Get the IDeviceEmulatorManagerVMID object.
                    hr = pDeviceEnumerator->GetVMID(&pDevice);
                    if (FAILED(hr)) {
                        continue;
                    }

                    // Output the name of the emulator.
                    hr = pDevice->get_Name(&deviceName);
                    if (FAILED(hr)){
                        continue;
                    }
                    wprintf_s(L"\t\t%s\n", deviceName);
                }
            }
        }
        return true;
        CoUninitialize();
    }
    return false;
}

要求

DEMComInterface.tlb


IEnumManagerSDKs::Reset

[image]

设备仿真程序
IEnumManagerSDKs::Reset

将内部迭代器移回列表中的第一个平台。

HRESULT Reset();

返回值

一个指示方法调用结果的 HRESULT 值。

要求

DEMComInterface.tlb


IEnumManagerSDKs::get_Name

[image]

设备仿真程序
IEnumManagerSDKs::get_Name
示例

获取当前平台的名称，例如“Windows Mobile 5.0 Smartphone SDK”。

HRESULT get_Name([out, retval] BSTR* pbstrName);

参数

[out] pbstrName

一个指针，它指向在方法调用后用当前平台的名称填充的 BSTR。

返回值

一个指示方法调用结果的 HRESULT 值。

示例

下面的示例将列出“设备仿真器管理器”窗口中的节点、SDK/平台和仿真程序。

“复制”图像 复制代码
int _tmain(int argc, _TCHAR* argv[])
{
    if (SUCCEEDED(CoInitializeEx(NULL, COINIT_MULTITHREADED)))
    {
        // HRESULT is used to determine whether method calls are successful
        HRESULT hr;

        // Instantiate DeviceEmulatorManager (DEM) object.
        // This starts DvcEmuManager.exe in silent mode

        CComPtr<IDeviceEmulatorManager> pDeviceEmulatorManager;
        hr = pDeviceEmulatorManager.CoCreateInstance(__uuidof(DeviceEmulatorManager));
        if (FAILED(hr)) {
            wprintf_s(L"Error: Unable to instantiate DeviceEmulatorManager. ErrorCode=0x%08X\n", hr);
            return false;
        }

        // For each of the four nodes in the Device Emulator Manager window
        // (Datastore, My Device Emulators, All Device Emulators, and Others)
        for (; SUCCEEDED(hr); (hr = pDeviceEmulatorManager->MoveNext()))
        {
            CComPtr<IEnumManagerSDKs> pSDKEnumerator;
            CComBSTR node;

            // Output the name of node
            hr = pDeviceEmulatorManager->get_Name(&node);
            if (FAILED(hr)) {
                wprintf_s(L"Error: Failed to get current SDK category name. ErrorCode=0x%08X\n", hr);
                return false;
            }
            wprintf_s(L"- %s\n", node);

            // Get a list of SDKs/platforms in this node
            hr = pDeviceEmulatorManager->EnumerateSDKs(&pSDKEnumerator);
            if (FAILED(hr)) {
                wprintf_s(L"Error: Failed to get enumerator for the SDK Category[%s]. ErrorCode=0x%08X\n", node, hr);
                return false;
            }

            // For every SDK/platform in the list
            for (; SUCCEEDED(hr); (hr = pSDKEnumerator->MoveNext()))
            {
                CComBSTR sdkName;

                // Output its name
                hr = pSDKEnumerator->get_Name(&sdkName);
                if (hr == E_ENUMSDK_NOT_LOADED ) {
                    continue;
                } else if (FAILED(hr)) {
                    wprintf_s(L"Error: Failed to get SDK details. ErrorCode=0x%08X\n", hr);
                    return false;
                }
                wprintf_s(L"\t- %s\n", sdkName);

                // Get the list of emulators in the SDK/platform
                CComPtr<IEnumVMIDs> pDeviceEnumerator;
                hr = pSDKEnumerator->EnumerateVMIDs(&pDeviceEnumerator);
                if (FAILED(hr)) {
                    wprintf_s(L"Error: Failed to get enumerator for VM devices. ErrorCode=0x%08X\n", hr);
                    return false;
                }

                // For every emulator in the list
                for (; SUCCEEDED(hr); (hr = pDeviceEnumerator->MoveNext()))
                {
                    CComBSTR deviceName;
                    CComPtr<IDeviceEmulatorManagerVMID> pDevice;

                    // Get the IDeviceEmulatorManagerVMID object.
                    hr = pDeviceEnumerator->GetVMID(&pDevice);
                    if (FAILED(hr)) {
                        continue;
                    }

                    // Output the name of the emulator.
                    hr = pDevice->get_Name(&deviceName);
                    if (FAILED(hr)){
                        continue;
                    }
                    wprintf_s(L"\t\t%s\n", deviceName);
                }
            }
        }
        return true;
        CoUninitialize();
    }
    return false;
}

要求

DEMComInterface.tlb


IEnumVMIDs

[image]

设备仿真程序
IEnumVMIDs
示例 请参见

此接口表示设备仿真器管理器 (DEM) 中的设备级节点，例如“Pocket PC 2003 Square 仿真程序”。

interface IEnumVMIDs : IDispatch {};

方法

方法 | 说明
IEnumVMIDs::get_VMID | 获取一个对象，该对象实现表示枚举中的当前设备的 IDeviceEmulatorManagerVMID。
IEnumVMIDs::MoveNext | 移至列表中的下一个设备。
IEnumVMIDs::Reset | 移回列表中的第一个设备。

备注

若要创建实现此接口的对象，请使用 IEnumManagerSDKs::EnumerateVMIDs。实现此接口的对象是一个链接列表，其中包含平台中的所有设备。

示例

下面的示例将列出“设备仿真器管理器”窗口中的节点、SDK/平台和仿真程序。

“复制”图像 复制代码
int _tmain(int argc, _TCHAR* argv[])
{
    if (SUCCEEDED(CoInitializeEx(NULL, COINIT_MULTITHREADED)))
    {
        // HRESULT is used to determine whether method calls are successful
        HRESULT hr;

        // Instantiate DeviceEmulatorManager (DEM) object.
        // This starts DvcEmuManager.exe in silent mode

        CComPtr<IDeviceEmulatorManager> pDeviceEmulatorManager;
        hr = pDeviceEmulatorManager.CoCreateInstance(__uuidof(DeviceEmulatorManager));
        if (FAILED(hr)) {
            wprintf_s(L"Error: Unable to instantiate DeviceEmulatorManager. ErrorCode=0x%08X\n", hr);
            return false;
        }

        // For each of the four nodes in the Device Emulator Manager window
        // (Datastore, My Device Emulators, All Device Emulators, and Others)
        for (; SUCCEEDED(hr); (hr = pDeviceEmulatorManager->MoveNext()))
        {
            CComPtr<IEnumManagerSDKs> pSDKEnumerator;
            CComBSTR node;

            // Output the name of node
            hr = pDeviceEmulatorManager->get_Name(&node);
            if (FAILED(hr)) {
                wprintf_s(L"Error: Failed to get current SDK category name. ErrorCode=0x%08X\n", hr);
                return false;
            }
            wprintf_s(L"- %s\n", node);

            // Get a list of SDKs/platforms in this node
            hr = pDeviceEmulatorManager->EnumerateSDKs(&pSDKEnumerator);
            if (FAILED(hr)) {
                wprintf_s(L"Error: Failed to get enumerator for the SDK Category[%s]. ErrorCode=0x%08X\n", node, hr);
                return false;
            }

            // For every SDK/platform in the list
            for (; SUCCEEDED(hr); (hr = pSDKEnumerator->MoveNext()))
            {
                CComBSTR sdkName;

                // Output its name
                hr = pSDKEnumerator->get_Name(&sdkName);
                if (hr == E_ENUMSDK_NOT_LOADED ) {
                    continue;
                } else if (FAILED(hr)) {
                    wprintf_s(L"Error: Failed to get SDK details. ErrorCode=0x%08X\n", hr);
                    return false;
                }
                wprintf_s(L"\t- %s\n", sdkName);

                // Get the list of emulators in the SDK/platform
                CComPtr<IEnumVMIDs> pDeviceEnumerator;
                hr = pSDKEnumerator->EnumerateVMIDs(&pDeviceEnumerator);
                if (FAILED(hr)) {
                    wprintf_s(L"Error: Failed to get enumerator for VM devices. ErrorCode=0x%08X\n", hr);
                    return false;
                }

                // For every emulator in the list
                for (; SUCCEEDED(hr); (hr = pDeviceEnumerator->MoveNext()))
                {
                    CComBSTR deviceName;
                    CComPtr<IDeviceEmulatorManagerVMID> pDevice;

                    // Get the IDeviceEmulatorManagerVMID object.
                    hr = pDeviceEnumerator->GetVMID(&pDevice);
                    if (FAILED(hr)) {
                        continue;
                    }

                    // Output the name of the emulator.
                    hr = pDevice->get_Name(&deviceName);
                    if (FAILED(hr)){
                        continue;
                    }
                    wprintf_s(L"\t\t%s\n", deviceName);
                }
            }
        }
        return true;
        CoUninitialize();
    }
    return false;
}

要求

DEMComInterface.tlb

请参见

其他资源

Device Emulator samples（设备仿真程序示例）


IEnumVMIDs::get_VMID

[image]

设备仿真程序
IEnumVMIDs::get_VMID
示例

获取一个对象，该对象实现表示枚举中的当前设备的 IDeviceEmulatorManagerVMID。

HRESULT GetVMID([out, retval] IDeviceEmulatorManagerVMID** ppVMID);

参数

[out, retval] ppVMID

一个指向某对象的指针，该对象实现表示枚举中的当前设备的 IDeviceEmulatorManagerVMID。

返回值

一个指示方法调用结果的 HRESULT 值。

示例

下面的示例将列出“设备仿真器管理器”窗口中的节点、SDK/平台和仿真程序。

“复制”图像 复制代码
int _tmain(int argc, _TCHAR* argv[])
{
    if (SUCCEEDED(CoInitializeEx(NULL, COINIT_MULTITHREADED)))
    {
        // HRESULT is used to determine whether method calls are successful
        HRESULT hr;

        // Instantiate DeviceEmulatorManager (DEM) object.
        // This starts DvcEmuManager.exe in silent mode

        CComPtr<IDeviceEmulatorManager> pDeviceEmulatorManager;
        hr = pDeviceEmulatorManager.CoCreateInstance(__uuidof(DeviceEmulatorManager));
        if (FAILED(hr)) {
            wprintf_s(L"Error: Unable to instantiate DeviceEmulatorManager. ErrorCode=0x%08X\n", hr);
            return false;
        }

        // For each of the four nodes in the Device Emulator Manager window
        // (Datastore, My Device Emulators, All Device Emulators, and Others)
        for (; SUCCEEDED(hr); (hr = pDeviceEmulatorManager->MoveNext()))
        {
            CComPtr<IEnumManagerSDKs> pSDKEnumerator;
            CComBSTR node;

            // Output the name of node
            hr = pDeviceEmulatorManager->get_Name(&node);
            if (FAILED(hr)) {
                wprintf_s(L"Error: Failed to get current SDK category name. ErrorCode=0x%08X\n", hr);
                return false;
            }
            wprintf_s(L"- %s\n", node);

            // Get a list of SDKs/platforms in this node
            hr = pDeviceEmulatorManager->EnumerateSDKs(&pSDKEnumerator);
            if (FAILED(hr)) {
                wprintf_s(L"Error: Failed to get enumerator for the SDK Category[%s]. ErrorCode=0x%08X\n", node, hr);
                return false;
            }

            // For every SDK/platform in the list
            for (; SUCCEEDED(hr); (hr = pSDKEnumerator->MoveNext()))
            {
                CComBSTR sdkName;

                // Output its name
                hr = pSDKEnumerator->get_Name(&sdkName);
                if (hr == E_ENUMSDK_NOT_LOADED ) {
                    continue;
                } else if (FAILED(hr)) {
                    wprintf_s(L"Error: Failed to get SDK details. ErrorCode=0x%08X\n", hr);
                    return false;
                }
                wprintf_s(L"\t- %s\n", sdkName);

                // Get the list of emulators in the SDK/platform
                CComPtr<IEnumVMIDs> pDeviceEnumerator;
                hr = pSDKEnumerator->EnumerateVMIDs(&pDeviceEnumerator);
                if (FAILED(hr)) {
                    wprintf_s(L"Error: Failed to get enumerator for VM devices. ErrorCode=0x%08X\n", hr);
                    return false;
                }

                // For every emulator in the list
                for (; SUCCEEDED(hr); (hr = pDeviceEnumerator->MoveNext()))
                {
                    CComBSTR deviceName;
                    CComPtr<IDeviceEmulatorManagerVMID> pDevice;

                    // Get the IDeviceEmulatorManagerVMID object.
                    hr = pDeviceEnumerator->GetVMID(&pDevice);
                    if (FAILED(hr)) {
                        continue;
                    }

                    // Output the name of the emulator.
                    hr = pDevice->get_Name(&deviceName);
                    if (FAILED(hr)){
                        continue;
                    }
                    wprintf_s(L"\t\t%s\n", deviceName);
                }
            }
        }
        return true;
        CoUninitialize();
    }
    return false;
}

要求

DEMComInterface.tlb


IEnumVMIDs::MoveNext

[image]

设备仿真程序
IEnumVMIDs::MoveNext
示例

移至列表中的下一个设备。

HRESULT MoveNext();

返回值

一个指示方法调用结果的 HRESULT 值。

示例

下面的示例将列出“设备仿真器管理器”窗口中的节点、SDK/平台和仿真程序。

“复制”图像 复制代码
int _tmain(int argc, _TCHAR* argv[])
{
    if (SUCCEEDED(CoInitializeEx(NULL, COINIT_MULTITHREADED)))
    {
        // HRESULT is used to determine whether method calls are successful
        HRESULT hr;

        // Instantiate DeviceEmulatorManager (DEM) object.
        // This starts DvcEmuManager.exe in silent mode

        CComPtr<IDeviceEmulatorManager> pDeviceEmulatorManager;
        hr = pDeviceEmulatorManager.CoCreateInstance(__uuidof(DeviceEmulatorManager));
        if (FAILED(hr)) {
            wprintf_s(L"Error: Unable to instantiate DeviceEmulatorManager. ErrorCode=0x%08X\n", hr);
            return false;
        }

        // For each of the four nodes in the Device Emulator Manager window
        // (Datastore, My Device Emulators, All Device Emulators, and Others)
        for (; SUCCEEDED(hr); (hr = pDeviceEmulatorManager->MoveNext()))
        {
            CComPtr<IEnumManagerSDKs> pSDKEnumerator;
            CComBSTR node;

            // Output the name of node
            hr = pDeviceEmulatorManager->get_Name(&node);
            if (FAILED(hr)) {
                wprintf_s(L"Error: Failed to get current SDK category name. ErrorCode=0x%08X\n", hr);
                return false;
            }
            wprintf_s(L"- %s\n", node);

            // Get a list of SDKs/platforms in this node
            hr = pDeviceEmulatorManager->EnumerateSDKs(&pSDKEnumerator);
            if (FAILED(hr)) {
                wprintf_s(L"Error: Failed to get enumerator for the SDK Category[%s]. ErrorCode=0x%08X\n", node, hr);
                return false;
            }

            // For every SDK/platform in the list
            for (; SUCCEEDED(hr); (hr = pSDKEnumerator->MoveNext()))
            {
                CComBSTR sdkName;

                // Output its name
                hr = pSDKEnumerator->get_Name(&sdkName);
                if (hr == E_ENUMSDK_NOT_LOADED ) {
                    continue;
                } else if (FAILED(hr)) {
                    wprintf_s(L"Error: Failed to get SDK details. ErrorCode=0x%08X\n", hr);
                    return false;
                }
                wprintf_s(L"\t- %s\n", sdkName);

                // Get the list of emulators in the SDK/platform
                CComPtr<IEnumVMIDs> pDeviceEnumerator;
                hr = pSDKEnumerator->EnumerateVMIDs(&pDeviceEnumerator);
                if (FAILED(hr)) {
                    wprintf_s(L"Error: Failed to get enumerator for VM devices. ErrorCode=0x%08X\n", hr);
                    return false;
                }

                // For every emulator in the list
                for (; SUCCEEDED(hr); (hr = pDeviceEnumerator->MoveNext()))
                {
                    CComBSTR deviceName;
                    CComPtr<IDeviceEmulatorManagerVMID> pDevice;

                    // Get the IDeviceEmulatorManagerVMID object.
                    hr = pDeviceEnumerator->GetVMID(&pDevice);
                    if (FAILED(hr)) {
                        continue;
                    }

                    // Output the name of the emulator.
                    hr = pDevice->get_Name(&deviceName);
                    if (FAILED(hr)){
                        continue;
                    }
                    wprintf_s(L"\t\t%s\n", deviceName);
                }
            }
        }
        return true;
        CoUninitialize();
    }
    return false;
}

要求

DEMComInterface.tlb


IEnumVMIDs::Reset

[image]

设备仿真程序
IEnumVMIDs::Reset

将内部迭代器移回列表中的第一个设备。

HRESULT Reset();

返回值

一个指示方法调用结果的 HRESULT 值。

要求

DEMComInterface.tlb


IDeviceEmulatorManagerVMID

[image]

设备仿真程序
IDeviceEmulatorManagerVMID
示例 请参见

此接口表示设备仿真器管理器 (DEM) 中的单个仿真程序。使用此接口可以对仿真程序执行连接、插入底座和重置等操作。

interface IDeviceEmulatorManagerVMID : IDispatch{}

方法

方法 | 说明
IDeviceEmulatorManagerVMID::get_VMID | 获取唯一标识仿真程序的虚拟机标识符 (VMID)。
IDeviceEmulatorManagerVMID::get_State | 获取仿真程序的当前状态。仿真程序的状态可以是未在运行、正在运行或已插入底座。
IDeviceEmulatorManagerVMID::get_Name | 获取仿真程序的名称，例如 Pocket PC 2003 SE 仿真程序。
IDeviceEmulatorManagerVMID::Connect | 启动设备仿真程序（如果尚未启动）并与它建立连接。
IDeviceEmulatorManagerVMID::Cradle | 将仿真程序插入底座。
IDeviceEmulatorManagerVMID::UnCradle | 移除仿真程序底座。
IDeviceEmulatorManagerVMID::Shutdown | 关闭仿真程序，并（可选）保存仿真程序的状态。
IDeviceEmulatorManagerVMID::Reset | 重置仿真程序。
IDeviceEmulatorManagerVMID::ClearSaveState | 清除与此设备关联的设备仿真程序保存状态文件 (.dess)。下次启动时，仿真程序将从其 ROM 映像而非其保存状态文件启动。
IDeviceEmulatorManagerVMID::BringToFront | 显示“设备仿真程序”窗口。
IDeviceEmulatorManagerVMID::GetConfiguration | 以设备仿真程序配置 XML 格式获取仿真程序的配置。
IDeviceEmulatorManagerVMID::SetConfiguration | 在给定正确格式化的设备仿真程序配置 XML 字符串时设置仿真程序的配置。

备注

若要创建实现此接口的对象，请使用 IEnumVMIDs::get_VMID。

示例

下面的示例将启动 Pocket PC 2003 仿真程序并执行多种操作。

“复制”图像 复制代码
BOOL FindDevice(const CComBSTR& deviceIdentifier, IDeviceEmulatorManagerVMID** pDeviceVMID);

int _tmain(int argc, _TCHAR* argv[])
{
    if (SUCCEEDED(CoInitializeEx(NULL, COINIT_MULTITHREADED)))
    {
        // HRESULT is used to determine whether method calls are successful
        HRESULT hr;
        CComPtr<IDeviceEmulatorManagerVMID> pDevice = NULL;

        // Get the emulator by calling a helper function
        hr = FindDevice("Pocket PC 2003 SE Emulator", &pDevice);

        // If the emulator is found
        if (SUCCEEDED(hr))
        {
            // Connect to the emulator
            hr = pDevice->Connect();
            if (SUCCEEDED(hr)) wprintf_s(L"Emulator is connected\n");

            system("pause");

            // Output the Device Emulator's configuration.
            BSTR bstrConfig;
            hr = pDevice->GetConfiguration(&bstrConfig);
            if (SUCCEEDED(hr)) wprintf_s(L"Get the device's configuration\n");
            wprintf_s(bstrConfig);

            system("pause");

            // Insert code here to modify the Device Emulator's configuration XML.

            // Set the Device Emulator's configuration
            hr = pDevice->SetConfiguration(bstrConfig);
            if (!SUCCEEDED(hr)) wprintf_s(L"Set the device's configuration\n");
            system("pause");

            // Perform a soft reset
            hr = pDevice->Reset(true);
            if (SUCCEEDED(hr)) wprintf_s(L"Resetting the device\n");
        }
    }
    return 0;
}

// Helper method to find a device given name or VMID
BOOL FindDevice(const CComBSTR& deviceIdentifier, IDeviceEmulatorManagerVMID** pDeviceVMID)
{
    HRESULT hr;

    // Instantiate DeviceEmulatorManager (DEM) object.
    //  This starts DvcEmuManager.exe in silent mode
    CComPtr<IDeviceEmulatorManager> pDeviceEmulatorManager;
    hr = pDeviceEmulatorManager.CoCreateInstance(__uuidof(DeviceEmulatorManager));
    if (FAILED(hr)) {
        wprintf_s(L"Error: Unable to instantiate DeviceEmulatorManager. ErrorCode=0x%08X\n", hr);
        return FALSE;
    }

    // For each of the four nodes in the Device Emulator Manager window
    // (Datastore, My Device Emulators, All Device Emulators, and Others)
    for (; SUCCEEDED(hr); (hr = pDeviceEmulatorManager->MoveNext()))
    {
        CComPtr<IEnumManagerSDKs> pSDKEnumerator;

        // Get a list of SDKs/platforms in this node
        hr = pDeviceEmulatorManager->EnumerateSDKs(&pSDKEnumerator);
        if (FAILED(hr)) {
            continue;
        }
        // For every SDK/platform in the list
        for (; SUCCEEDED(hr); (hr = pSDKEnumerator->MoveNext()))
        {
            // Get the list of emulators in the SDK/platform
            CComPtr<IEnumVMIDs> pDeviceEnumerator;
            hr = pSDKEnumerator->EnumerateVMIDs(&pDeviceEnumerator);
            if (FAILED(hr)) {
                continue;
            }
            // For every emulator in the list
            for (; SUCCEEDED(hr); (hr = pDeviceEnumerator->MoveNext()))
            {
                CComBSTR deviceName;
                CComPtr<IDeviceEmulatorManagerVMID> pDevice;

                // Get the IDeviceEmulatorManagerVMID object.
                hr = pDeviceEnumerator->GetVMID(&pDevice);
                if (FAILED(hr)) {
                    continue;
                }

                // Get the name of the emulator
                hr = pDevice->get_Name(&deviceName);
                if (FAILED(hr)){
                    continue;
                }

                // If the name of the device matches the supplied name,
                // then this is the device we are looking for.
                if (deviceIdentifier == deviceName){
                    *pDeviceVMID = pDevice;
                    (*pDeviceVMID)->AddRef();
                    return TRUE;
                }
            }
        }
    }
    wprintf_s(L"Error: Unable to locate the device '%s'", deviceIdentifier);
    return FALSE;
}

要求

DEMComInterface.tlb

请参见

其他资源

Device Emulator samples（设备仿真程序示例）


IDeviceEmulatorManagerVMID::get_VMID

[image]

设备仿真程序
IDeviceEmulatorManagerVMID::get_VMID
示例

获取唯一标识仿真程序的虚拟机标识符 (VMID)。

HRESULT get_VMID([out, retval] BSTR* pVMID);

参数

[out,retval] pVMID

一个指针，它指向包含仿真程序 VMID 的字符串。

返回值

一个指示方法调用结果的 HRESULT 值。

示例

下面的示例将使用 IDeviceEmulatorManagerVMID 启动 Pocket PC 2003 仿真程序并执行多种操作。

“复制”图像 复制代码
BOOL FindDevice(const CComBSTR& deviceIdentifier, IDeviceEmulatorManagerVMID** pDeviceVMID);

int _tmain(int argc, _TCHAR* argv[])
{
    if (SUCCEEDED(CoInitializeEx(NULL, COINIT_MULTITHREADED)))
    {
        HRESULT hr;
        CComPtr<IDeviceEmulatorManagerVMID> pDevice = NULL;

        // Get the emulator by calling a helper function
        hr = FindDevice("Pocket PC 2003 SE Emulator", &pDevice);

        // If the emulator is found
        if (SUCCEEDED(hr))
        {
            CComBSTR VMID;
            CComBSTR deviceName;
            EMULATOR_STATE deviceState = EMU_NOT_RUNNING;

            // Output the name of the emulator
            hr = pDevice->get_Name(&deviceName);
            if (SUCCEEDED(hr)) wprintf_s(L"Device Name: %s\n", deviceName);

            // Output the emulator's VMID
            hr = pDevice->get_VMID(&VMID);
            if (SUCCEEDED(hr)) wprintf_s(L"Device VMID: %s\n", VMID);

            // Output the emulator's current state
            hr = pDevice->get_State(&deviceState);
            if (SUCCEEDED(hr))
            {
                if (deviceState == EMU_CRADLED) wprintf_s(L"Emulator is Cradled\n");
                else if (deviceState == EMU_RUNNING) wprintf_s(L"Emulator is Running\n");
                else wprintf_s(L"Emulator is Not Running\n");
            }

            // Connect to the emulator
            hr = pDevice->Connect();
            if (SUCCEEDED(hr)) wprintf_s(L"Emulator is connected\n");

            // Make the Device Emulator window visible
            hr = pDevice->BringToFront();
            if (SUCCEEDED(hr)) wprintf_s(L"Device Emulator window is on top\n");

            // Cradle the emulator
            hr = pDevice->Cradle();
            if (SUCCEEDED(hr)) wprintf_s(L"Emulator is cradled\n");

            system("pause");

            // Uncradle the emulator
            hr = pDevice->UnCradle();
            if (SUCCEEDED(hr)) wprintf_s(L"Emulator is uncradled\n");

            // Save state and shutdown the emulator
            hr = pDevice->Shutdown(true);
            if (SUCCEEDED(hr)) wprintf_s(L"Emulator is shutdown\n");

            // Delete the .dess save state file for this device
            hr = pDevice->ClearSaveState();
            if (SUCCEEDED(hr)) wprintf_s(L"Save state file is deleted");

            system("pause");
        }
    }
    return 0;
}

// Helper method to find a device given name or VMID
BOOL FindDevice(const CComBSTR& deviceIdentifier, IDeviceEmulatorManagerVMID** pDeviceVMID)
{
    HRESULT hr;

    // Instantiate DeviceEmulatorManager (DEM) object.
    //  This starts DvcEmuManager.exe in silent mode
    CComPtr<IDeviceEmulatorManager> pDeviceEmulatorManager;
    hr = pDeviceEmulatorManager.CoCreateInstance(__uuidof(DeviceEmulatorManager));
    if (FAILED(hr)) {
        wprintf_s(L"Error: Unable to instantiate DeviceEmulatorManager. ErrorCode=0x%08X\n", hr);
        return FALSE;
    }

    // For each of the four nodes in the Device Emulator Manager window
    // (Datastore, My Device Emulators, All Device Emulators, and Others)
    for (; SUCCEEDED(hr); (hr = pDeviceEmulatorManager->MoveNext()))
    {
        CComPtr<IEnumManagerSDKs> pSDKEnumerator;

        // Get a list of SDKs/platforms in this node
        hr = pDeviceEmulatorManager->EnumerateSDKs(&pSDKEnumerator);
        if (FAILED(hr)) {
            continue;
        }

        // For every SDK/platform in the list
        for (; SUCCEEDED(hr); (hr = pSDKEnumerator->MoveNext()))
        {

            // Get the list of emulators in the SDK/platform
            CComPtr<IEnumVMIDs> pDeviceEnumerator;
            hr = pSDKEnumerator->EnumerateVMIDs(&pDeviceEnumerator);
            if (FAILED(hr)) {
                continue;
            }

            // For every emulator in the list
            for (; SUCCEEDED(hr); (hr = pDeviceEnumerator->MoveNext()))
            {
                CComBSTR deviceName;
                CComPtr<IDeviceEmulatorManagerVMID> pDevice;

                // Get the IDeviceEmulatorManagerVMID object.
                hr = pDeviceEnumerator->GetVMID(&pDevice);
                if (FAILED(hr)) {
                    continue;
                }

                // Get the name of the emulator
                hr = pDevice->get_Name(&deviceName);
                if (FAILED(hr)){
                    continue;
                }

                // If the name of the device matches the supplied name,
                // then this is the device we are looking for.
                if (deviceIdentifier == deviceName){
                    *pDeviceVMID = pDevice;
                    (*pDeviceVMID)->AddRef();
                    return TRUE;
                }
            }
        }
    }
    wprintf_s(L"Error: Unable to locate the device '%s'", deviceIdentifier);
    return FALSE;
}

要求

DEMComInterface.tlb


IDeviceEmulatorManagerVMID::get_State

[image]

设备仿真程序
IDeviceEmulatorManagerVMID::get_State
示例

获取仿真程序的当前状态。

HRESULT get_State([out, retval] int* pState);

参数

[out,retval] pState

一个指针，它指向表示仿真程序当前状态的 EMULATOR_STATE 枚举。

返回值

一个指示方法调用结果的 HRESULT 值。

备注

仿真程序的状态可以是未在运行、正在运行或已插入底座。

示例

下面的示例将使用 IDeviceEmulatorManagerVMID 启动 Pocket PC 2003 仿真程序并执行多种操作。

“复制”图像 复制代码
BOOL FindDevice(const CComBSTR& deviceIdentifier, IDeviceEmulatorManagerVMID** pDeviceVMID);

int _tmain(int argc, _TCHAR* argv[])
{
    if (SUCCEEDED(CoInitializeEx(NULL, COINIT_MULTITHREADED)))
    {
        HRESULT hr;
        CComPtr<IDeviceEmulatorManagerVMID> pDevice = NULL;

        // Get the emulator by calling a helper function
        hr = FindDevice("Pocket PC 2003 SE Emulator", &pDevice);

        // If the emulator is found
        if (SUCCEEDED(hr))
        {
            CComBSTR VMID;
            CComBSTR deviceName;
            EMULATOR_STATE deviceState = EMU_NOT_RUNNING;

            // Output the name of the emulator
            hr = pDevice->get_Name(&deviceName);
            if (SUCCEEDED(hr)) wprintf_s(L"Device Name: %s\n", deviceName);

            // Output the emulator's VMID
            hr = pDevice->get_VMID(&VMID);
            if (SUCCEEDED(hr)) wprintf_s(L"Device VMID: %s\n", VMID);

            // Output the emulator's current state
            hr = pDevice->get_State(&deviceState);
            if (SUCCEEDED(hr))
            {
                if (deviceState == EMU_CRADLED) wprintf_s(L"Emulator is Cradled\n");
                else if (deviceState == EMU_RUNNING) wprintf_s(L"Emulator is Running\n");
                else wprintf_s(L"Emulator is Not Running\n");
            }

            // Connect to the emulator
            hr = pDevice->Connect();
            if (SUCCEEDED(hr)) wprintf_s(L"Emulator is connected\n");

            // Make the Device Emulator window visible
            hr = pDevice->BringToFront();
            if (SUCCEEDED(hr)) wprintf_s(L"Device Emulator window is on top\n");

            // Cradle the emulator
            hr = pDevice->Cradle();
            if (SUCCEEDED(hr)) wprintf_s(L"Emulator is cradled\n");

            system("pause");

            // Uncradle the emulator
            hr = pDevice->UnCradle();
            if (SUCCEEDED(hr)) wprintf_s(L"Emulator is uncradled\n");

            // Save state and shutdown the emulator
            hr = pDevice->Shutdown(true);
            if (SUCCEEDED(hr)) wprintf_s(L"Emulator is shutdown\n");

            // Delete the .dess save state file for this device
            hr = pDevice->ClearSaveState();
            if (SUCCEEDED(hr)) wprintf_s(L"Save state file is deleted");

            system("pause");
        }
    }
    return 0;
}

// Helper method to find a device given name or VMID
BOOL FindDevice(const CComBSTR& deviceIdentifier, IDeviceEmulatorManagerVMID** pDeviceVMID)
{
    HRESULT hr;

    // Instantiate DeviceEmulatorManager (DEM) object.
    //  This starts DvcEmuManager.exe in silent mode
    CComPtr<IDeviceEmulatorManager> pDeviceEmulatorManager;
    hr = pDeviceEmulatorManager.CoCreateInstance(__uuidof(DeviceEmulatorManager));
    if (FAILED(hr)) {
        wprintf_s(L"Error: Unable to instantiate DeviceEmulatorManager. ErrorCode=0x%08X\n", hr);
        return FALSE;
    }

    // For each of the four nodes in the Device Emulator Manager window
    // (Datastore, My Device Emulators, All Device Emulators, and Others)
    for (; SUCCEEDED(hr); (hr = pDeviceEmulatorManager->MoveNext()))
    {
        CComPtr<IEnumManagerSDKs> pSDKEnumerator;

        // Get a list of SDKs/platforms in this node
        hr = pDeviceEmulatorManager->EnumerateSDKs(&pSDKEnumerator);
        if (FAILED(hr)) {
            continue;
        }

        // For every SDK/platform in the list
        for (; SUCCEEDED(hr); (hr = pSDKEnumerator->MoveNext()))
        {

            // Get the list of emulators in the SDK/platform
            CComPtr<IEnumVMIDs> pDeviceEnumerator;
            hr = pSDKEnumerator->EnumerateVMIDs(&pDeviceEnumerator);
            if (FAILED(hr)) {
                continue;
            }

            // For every emulator in the list
            for (; SUCCEEDED(hr); (hr = pDeviceEnumerator->MoveNext()))
            {
                CComBSTR deviceName;
                CComPtr<IDeviceEmulatorManagerVMID> pDevice;

                // Get the IDeviceEmulatorManagerVMID object.
                hr = pDeviceEnumerator->GetVMID(&pDevice);
                if (FAILED(hr)) {
                    continue;
                }

                // Get the name of the emulator
                hr = pDevice->get_Name(&deviceName);
                if (FAILED(hr)){
                    continue;
                }

                // If the name of the device matches the supplied name,
                // then this is the device we are looking for.
                if (deviceIdentifier == deviceName){
                    *pDeviceVMID = pDevice;
                    (*pDeviceVMID)->AddRef();
                    return TRUE;
                }
            }
        }
    }
    wprintf_s(L"Error: Unable to locate the device '%s'", deviceIdentifier);
    return FALSE;
}

要求

DEMComInterface.tlb


IDeviceEmulatorManagerVMID::get_Name

[image]

设备仿真程序
IDeviceEmulatorManagerVMID::get_Name
示例

获取仿真程序的名称，例如 Pocket PC 2003 SE 仿真程序。

HRESULT get_Name([out, retval] BSTR* pbstrName);

参数

[out, retval] pbstrName

一个指针，它指向在方法返回后包含仿真程序名称的字符串。

返回值

一个指示方法调用结果的 HRESULT 值。

示例

下面的示例将使用 IDeviceEmulatorManagerVMID 启动 Pocket PC 2003 仿真程序并执行多种操作。

“复制”图像 复制代码
BOOL FindDevice(const CComBSTR& deviceIdentifier, IDeviceEmulatorManagerVMID** pDeviceVMID);

int _tmain(int argc, _TCHAR* argv[])
{
    if (SUCCEEDED(CoInitializeEx(NULL, COINIT_MULTITHREADED)))
    {
        HRESULT hr;
        CComPtr<IDeviceEmulatorManagerVMID> pDevice = NULL;

        // Get the emulator by calling a helper function
        hr = FindDevice("Pocket PC 2003 SE Emulator", &pDevice);

        // If the emulator is found
        if (SUCCEEDED(hr))
        {
            CComBSTR VMID;
            CComBSTR deviceName;
            EMULATOR_STATE deviceState = EMU_NOT_RUNNING;

            // Output the name of the emulator
            hr = pDevice->get_Name(&deviceName);
            if (SUCCEEDED(hr)) wprintf_s(L"Device Name: %s\n", deviceName);

            // Output the emulator's VMID
            hr = pDevice->get_VMID(&VMID);
            if (SUCCEEDED(hr)) wprintf_s(L"Device VMID: %s\n", VMID);

            // Output the emulator's current state
            hr = pDevice->get_State(&deviceState);
            if (SUCCEEDED(hr))
            {
                if (deviceState == EMU_CRADLED) wprintf_s(L"Emulator is Cradled\n");
                else if (deviceState == EMU_RUNNING) wprintf_s(L"Emulator is Running\n");
                else wprintf_s(L"Emulator is Not Running\n");
            }

            // Connect to the emulator
            hr = pDevice->Connect();
            if (SUCCEEDED(hr)) wprintf_s(L"Emulator is connected\n");

            // Make the Device Emulator window visible
            hr = pDevice->BringToFront();
            if (SUCCEEDED(hr)) wprintf_s(L"Device Emulator window is on top\n");

            // Cradle the emulator
            hr = pDevice->Cradle();
            if (SUCCEEDED(hr)) wprintf_s(L"Emulator is cradled\n");

            system("pause");

            // Uncradle the emulator
            hr = pDevice->UnCradle();
            if (SUCCEEDED(hr)) wprintf_s(L"Emulator is uncradled\n");

            // Save state and shutdown the emulator
            hr = pDevice->Shutdown(true);
            if (SUCCEEDED(hr)) wprintf_s(L"Emulator is shutdown\n");

            // Delete the .dess save state file for this device
            hr = pDevice->ClearSaveState();
            if (SUCCEEDED(hr)) wprintf_s(L"Save state file is deleted");

            system("pause");
        }
    }
    return 0;
}

// Helper method to find a device given name or VMID
BOOL FindDevice(const CComBSTR& deviceIdentifier, IDeviceEmulatorManagerVMID** pDeviceVMID)
{
    HRESULT hr;

    // Instantiate DeviceEmulatorManager (DEM) object.
    //  This starts DvcEmuManager.exe in silent mode
    CComPtr<IDeviceEmulatorManager> pDeviceEmulatorManager;
    hr = pDeviceEmulatorManager.CoCreateInstance(__uuidof(DeviceEmulatorManager));
    if (FAILED(hr)) {
        wprintf_s(L"Error: Unable to instantiate DeviceEmulatorManager. ErrorCode=0x%08X\n", hr);
        return FALSE;
    }

    // For each of the four nodes in the Device Emulator Manager window
    // (Datastore, My Device Emulators, All Device Emulators, and Others)
    for (; SUCCEEDED(hr); (hr = pDeviceEmulatorManager->MoveNext()))
    {
        CComPtr<IEnumManagerSDKs> pSDKEnumerator;

        // Get a list of SDKs/platforms in this node
        hr = pDeviceEmulatorManager->EnumerateSDKs(&pSDKEnumerator);
        if (FAILED(hr)) {
            continue;
        }

        // For every SDK/platform in the list
        for (; SUCCEEDED(hr); (hr = pSDKEnumerator->MoveNext()))
        {

            // Get the list of emulators in the SDK/platform
            CComPtr<IEnumVMIDs> pDeviceEnumerator;
            hr = pSDKEnumerator->EnumerateVMIDs(&pDeviceEnumerator);
            if (FAILED(hr)) {
                continue;
            }

            // For every emulator in the list
            for (; SUCCEEDED(hr); (hr = pDeviceEnumerator->MoveNext()))
            {
                CComBSTR deviceName;
                CComPtr<IDeviceEmulatorManagerVMID> pDevice;

                // Get the IDeviceEmulatorManagerVMID object.
                hr = pDeviceEnumerator->GetVMID(&pDevice);
                if (FAILED(hr)) {
                    continue;
                }

                // Get the name of the emulator
                hr = pDevice->get_Name(&deviceName);
                if (FAILED(hr)){
                    continue;
                }

                // If the name of the device matches the supplied name,
                // then this is the device we are looking for.
                if (deviceIdentifier == deviceName){
                    *pDeviceVMID = pDevice;
                    (*pDeviceVMID)->AddRef();
                    return TRUE;
                }
            }
        }
    }
    wprintf_s(L"Error: Unable to locate the device '%s'", deviceIdentifier);
    return FALSE;
}

要求

DEMComInterface.tlb


IDeviceEmulatorManagerVMID::Connect

[image]

设备仿真程序
IDeviceEmulatorManagerVMID::Connect
示例

启动设备仿真程序（如果尚未启动）并与它建立连接。

HRESULT Connect();

返回值

一个指示方法调用结果的 HRESULT 值。

备注

这相当于在“设备仿真器管理器”窗口中的“操作”菜单中选择“连接”。

示例

下面的示例将使用 IDeviceEmulatorManagerVMID 启动 Pocket PC 2003 仿真程序并执行多种操作。

“复制”图像 复制代码
BOOL FindDevice(const CComBSTR& deviceIdentifier, IDeviceEmulatorManagerVMID** pDeviceVMID);

int _tmain(int argc, _TCHAR* argv[])
{
    if (SUCCEEDED(CoInitializeEx(NULL, COINIT_MULTITHREADED)))
    {
        // HRESULT is used to determine whether method calls are successful
        HRESULT hr;
        CComPtr<IDeviceEmulatorManagerVMID> pDevice = NULL;

        // Get the emulator by calling a helper function
        hr = FindDevice("Pocket PC 2003 SE Emulator", &pDevice);

        // If the emulator is found
        if (SUCCEEDED(hr))
        {
            // Connect to the emulator
            hr = pDevice->Connect();
            if (SUCCEEDED(hr)) wprintf_s(L"Emulator is connected\n");

            system("pause");

            // Output the Device Emulator's configuration.
            BSTR bstrConfig;
            hr = pDevice->GetConfiguration(&bstrConfig);
            if (SUCCEEDED(hr)) wprintf_s(L"Get the device's configuration\n");
            wprintf_s(bstrConfig);

            system("pause");

            // Insert code here to modify the Device Emulator's configuration XML.

            // Set the Device Emulator's configuration
            hr = pDevice->SetConfiguration(bstrConfig);
            if (!SUCCEEDED(hr)) wprintf_s(L"Set the device's configuration\n");
            system("pause");

            // Perform a soft reset
            hr = pDevice->Reset(true);
            if (SUCCEEDED(hr)) wprintf_s(L"Resetting the device\n");
        }
    }
    return 0;
}

// Helper method to find a device given name or VMID
BOOL FindDevice(const CComBSTR& deviceIdentifier, IDeviceEmulatorManagerVMID** pDeviceVMID)
{
    HRESULT hr;

    // Instantiate DeviceEmulatorManager (DEM) object.
    //  This starts DvcEmuManager.exe in silent mode
    CComPtr<IDeviceEmulatorManager> pDeviceEmulatorManager;
    hr = pDeviceEmulatorManager.CoCreateInstance(__uuidof(DeviceEmulatorManager));
    if (FAILED(hr)) {
        wprintf_s(L"Error: Unable to instantiate DeviceEmulatorManager. ErrorCode=0x%08X\n", hr);
        return FALSE;
    }

    // For each of the four nodes in the Device Emulator Manager window
    // (Datastore, My Device Emulators, All Device Emulators, and Others)
    for (; SUCCEEDED(hr); (hr = pDeviceEmulatorManager->MoveNext()))
    {
        CComPtr<IEnumManagerSDKs> pSDKEnumerator;

        // Get a list of SDKs/platforms in this node
        hr = pDeviceEmulatorManager->EnumerateSDKs(&pSDKEnumerator);
        if (FAILED(hr)) {
            continue;
        }
        // For every SDK/platform in the list
        for (; SUCCEEDED(hr); (hr = pSDKEnumerator->MoveNext()))
        {
            // Get the list of emulators in the SDK/platform
            CComPtr<IEnumVMIDs> pDeviceEnumerator;
            hr = pSDKEnumerator->EnumerateVMIDs(&pDeviceEnumerator);
            if (FAILED(hr)) {
                continue;
            }
            // For every emulator in the list
            for (; SUCCEEDED(hr); (hr = pDeviceEnumerator->MoveNext()))
            {
                CComBSTR deviceName;
                CComPtr<IDeviceEmulatorManagerVMID> pDevice;

                // Get the IDeviceEmulatorManagerVMID object.
                hr = pDeviceEnumerator->GetVMID(&pDevice);
                if (FAILED(hr)) {
                    continue;
                }

                // Get the name of the emulator
                hr = pDevice->get_Name(&deviceName);
                if (FAILED(hr)){
                    continue;
                }

                // If the name of the device matches the supplied name,
                // then this is the device we are looking for.
                if (deviceIdentifier == deviceName){
                    *pDeviceVMID = pDevice;
                    (*pDeviceVMID)->AddRef();
                    return TRUE;
                }
            }
        }
    }
    wprintf_s(L"Error: Unable to locate the device '%s'", deviceIdentifier);
    return FALSE;
}

要求

DEMComInterface.tlb


IDeviceEmulatorManagerVMID::Cradle

[image]

设备仿真程序
IDeviceEmulatorManagerVMID::Cradle
示例

将仿真程序插入底座。

HRESULT Cradle();

返回值

一个指示方法调用结果的 HRESULT 值。

备注

这相当于在“设备仿真器管理器”窗口中的“操作”菜单中选择“插入底座”。

ActiveSync 或 Windows Mobile 设备中心 (Windows Vista) 可以配置为识别插入底座的设备仿真程序并与之建立同步合作关系。

注意 注意：

ActiveSync 或 Windows Mobile 设备中心 (Windows Vista) 必须配置为允许建立 DMA 连接才能使用设备仿真程序。

示例

下面的示例将使用 IDeviceEmulatorManagerVMID 启动 Pocket PC 2003 仿真程序并执行多种操作。

“复制”图像 复制代码
BOOL FindDevice(const CComBSTR& deviceIdentifier, IDeviceEmulatorManagerVMID** pDeviceVMID);

int _tmain(int argc, _TCHAR* argv[])
{
    if (SUCCEEDED(CoInitializeEx(NULL, COINIT_MULTITHREADED)))
    {
        HRESULT hr;
        CComPtr<IDeviceEmulatorManagerVMID> pDevice = NULL;

        // Get the emulator by calling a helper function
        hr = FindDevice("Pocket PC 2003 SE Emulator", &pDevice);

        // If the emulator is found
        if (SUCCEEDED(hr))
        {
            CComBSTR VMID;
            CComBSTR deviceName;
            EMULATOR_STATE deviceState = EMU_NOT_RUNNING;

            // Output the name of the emulator
            hr = pDevice->get_Name(&deviceName);
            if (SUCCEEDED(hr)) wprintf_s(L"Device Name: %s\n", deviceName);

            // Output the emulator's VMID
            hr = pDevice->get_VMID(&VMID);
            if (SUCCEEDED(hr)) wprintf_s(L"Device VMID: %s\n", VMID);

            // Output the emulator's current state
            hr = pDevice->get_State(&deviceState);
            if (SUCCEEDED(hr))
            {
                if (deviceState == EMU_CRADLED) wprintf_s(L"Emulator is Cradled\n");
                else if (deviceState == EMU_RUNNING) wprintf_s(L"Emulator is Running\n");
                else wprintf_s(L"Emulator is Not Running\n");
            }

            // Connect to the emulator
            hr = pDevice->Connect();
            if (SUCCEEDED(hr)) wprintf_s(L"Emulator is connected\n");

            // Make the Device Emulator window visible
            hr = pDevice->BringToFront();
            if (SUCCEEDED(hr)) wprintf_s(L"Device Emulator window is on top\n");

            // Cradle the emulator
            hr = pDevice->Cradle();
            if (SUCCEEDED(hr)) wprintf_s(L"Emulator is cradled\n");

            system("pause");

            // Uncradle the emulator
            hr = pDevice->UnCradle();
            if (SUCCEEDED(hr)) wprintf_s(L"Emulator is uncradled\n");

            // Save state and shutdown the emulator
            hr = pDevice->Shutdown(true);
            if (SUCCEEDED(hr)) wprintf_s(L"Emulator is shutdown\n");

            // Delete the .dess save state file for this device
            hr = pDevice->ClearSaveState();
            if (SUCCEEDED(hr)) wprintf_s(L"Save state file is deleted");

            system("pause");
        }
    }
    return 0;
}

// Helper method to find a device given name or VMID
BOOL FindDevice(const CComBSTR& deviceIdentifier, IDeviceEmulatorManagerVMID** pDeviceVMID)
{
    HRESULT hr;

    // Instantiate DeviceEmulatorManager (DEM) object.
    //  This starts DvcEmuManager.exe in silent mode
    CComPtr<IDeviceEmulatorManager> pDeviceEmulatorManager;
    hr = pDeviceEmulatorManager.CoCreateInstance(__uuidof(DeviceEmulatorManager));
    if (FAILED(hr)) {
        wprintf_s(L"Error: Unable to instantiate DeviceEmulatorManager. ErrorCode=0x%08X\n", hr);
        return FALSE;
    }

    // For each of the four nodes in the Device Emulator Manager window
    // (Datastore, My Device Emulators, All Device Emulators, and Others)
    for (; SUCCEEDED(hr); (hr = pDeviceEmulatorManager->MoveNext()))
    {
        CComPtr<IEnumManagerSDKs> pSDKEnumerator;

        // Get a list of SDKs/platforms in this node
        hr = pDeviceEmulatorManager->EnumerateSDKs(&pSDKEnumerator);
        if (FAILED(hr)) {
            continue;
        }

        // For every SDK/platform in the list
        for (; SUCCEEDED(hr); (hr = pSDKEnumerator->MoveNext()))
        {

            // Get the list of emulators in the SDK/platform
            CComPtr<IEnumVMIDs> pDeviceEnumerator;
            hr = pSDKEnumerator->EnumerateVMIDs(&pDeviceEnumerator);
            if (FAILED(hr)) {
                continue;
            }

            // For every emulator in the list
            for (; SUCCEEDED(hr); (hr = pDeviceEnumerator->MoveNext()))
            {
                CComBSTR deviceName;
                CComPtr<IDeviceEmulatorManagerVMID> pDevice;

                // Get the IDeviceEmulatorManagerVMID object.
                hr = pDeviceEnumerator->GetVMID(&pDevice);
                if (FAILED(hr)) {
                    continue;
                }

                // Get the name of the emulator
                hr = pDevice->get_Name(&deviceName);
                if (FAILED(hr)){
                    continue;
                }

                // If the name of the device matches the supplied name,
                // then this is the device we are looking for.
                if (deviceIdentifier == deviceName){
                    *pDeviceVMID = pDevice;
                    (*pDeviceVMID)->AddRef();
                    return TRUE;
                }
            }
        }
    }
    wprintf_s(L"Error: Unable to locate the device '%s'", deviceIdentifier);
    return FALSE;
}

要求

DEMComInterface.tlb


IDeviceEmulatorManagerVMID::UnCradle

[image]

设备仿真程序
IDeviceEmulatorManagerVMID::UnCradle
示例

移除仿真程序底座。

HRESULT UnCradle();

返回值

一个指示方法调用结果的 HRESULT 值。

备注

这相当于在“设备仿真器管理器”窗口中的“操作”菜单中选择“移除底座”。

ActiveSync 或 Windows Mobile 设备中心 (Windows Vista) 可以配置为识别插入底座的设备仿真程序并与之建立同步合作关系。

注意 注意：

ActiveSync 或 Windows Mobile 设备中心 (Windows Vista) 必须配置为允许建立 DMA 连接才能使用设备仿真程序。

示例

下面的示例将使用 IDeviceEmulatorManagerVMID 启动 Pocket PC 2003 仿真程序并执行多种操作。

“复制”图像 复制代码
BOOL FindDevice(const CComBSTR& deviceIdentifier, IDeviceEmulatorManagerVMID** pDeviceVMID);

int _tmain(int argc, _TCHAR* argv[])
{
    if (SUCCEEDED(CoInitializeEx(NULL, COINIT_MULTITHREADED)))
    {
        HRESULT hr;
        CComPtr<IDeviceEmulatorManagerVMID> pDevice = NULL;

        // Get the emulator by calling a helper function
        hr = FindDevice("Pocket PC 2003 SE Emulator", &pDevice);

        // If the emulator is found
        if (SUCCEEDED(hr))
        {
            CComBSTR VMID;
            CComBSTR deviceName;
            EMULATOR_STATE deviceState = EMU_NOT_RUNNING;

            // Output the name of the emulator
            hr = pDevice->get_Name(&deviceName);
            if (SUCCEEDED(hr)) wprintf_s(L"Device Name: %s\n", deviceName);

            // Output the emulator's VMID
            hr = pDevice->get_VMID(&VMID);
            if (SUCCEEDED(hr)) wprintf_s(L"Device VMID: %s\n", VMID);

            // Output the emulator's current state
            hr = pDevice->get_State(&deviceState);
            if (SUCCEEDED(hr))
            {
                if (deviceState == EMU_CRADLED) wprintf_s(L"Emulator is Cradled\n");
                else if (deviceState == EMU_RUNNING) wprintf_s(L"Emulator is Running\n");
                else wprintf_s(L"Emulator is Not Running\n");
            }

            // Connect to the emulator
            hr = pDevice->Connect();
            if (SUCCEEDED(hr)) wprintf_s(L"Emulator is connected\n");

            // Make the Device Emulator window visible
            hr = pDevice->BringToFront();
            if (SUCCEEDED(hr)) wprintf_s(L"Device Emulator window is on top\n");

            // Cradle the emulator
            hr = pDevice->Cradle();
            if (SUCCEEDED(hr)) wprintf_s(L"Emulator is cradled\n");

            system("pause");

            // Uncradle the emulator
            hr = pDevice->UnCradle();
            if (SUCCEEDED(hr)) wprintf_s(L"Emulator is uncradled\n");

            // Save state and shutdown the emulator
            hr = pDevice->Shutdown(true);
            if (SUCCEEDED(hr)) wprintf_s(L"Emulator is shutdown\n");

            // Delete the .dess save state file for this device
            hr = pDevice->ClearSaveState();
            if (SUCCEEDED(hr)) wprintf_s(L"Save state file is deleted");

            system("pause");
        }
    }
    return 0;
}

// Helper method to find a device given name or VMID
BOOL FindDevice(const CComBSTR& deviceIdentifier, IDeviceEmulatorManagerVMID** pDeviceVMID)
{
    HRESULT hr;

    // Instantiate DeviceEmulatorManager (DEM) object.
    //  This starts DvcEmuManager.exe in silent mode
    CComPtr<IDeviceEmulatorManager> pDeviceEmulatorManager;
    hr = pDeviceEmulatorManager.CoCreateInstance(__uuidof(DeviceEmulatorManager));
    if (FAILED(hr)) {
        wprintf_s(L"Error: Unable to instantiate DeviceEmulatorManager. ErrorCode=0x%08X\n", hr);
        return FALSE;
    }

    // For each of the four nodes in the Device Emulator Manager window
    // (Datastore, My Device Emulators, All Device Emulators, and Others)
    for (; SUCCEEDED(hr); (hr = pDeviceEmulatorManager->MoveNext()))
    {
        CComPtr<IEnumManagerSDKs> pSDKEnumerator;

        // Get a list of SDKs/platforms in this node
        hr = pDeviceEmulatorManager->EnumerateSDKs(&pSDKEnumerator);
        if (FAILED(hr)) {
            continue;
        }

        // For every SDK/platform in the list
        for (; SUCCEEDED(hr); (hr = pSDKEnumerator->MoveNext()))
        {

            // Get the list of emulators in the SDK/platform
            CComPtr<IEnumVMIDs> pDeviceEnumerator;
            hr = pSDKEnumerator->EnumerateVMIDs(&pDeviceEnumerator);
            if (FAILED(hr)) {
                continue;
            }

            // For every emulator in the list
            for (; SUCCEEDED(hr); (hr = pDeviceEnumerator->MoveNext()))
            {
                CComBSTR deviceName;
                CComPtr<IDeviceEmulatorManagerVMID> pDevice;

                // Get the IDeviceEmulatorManagerVMID object.
                hr = pDeviceEnumerator->GetVMID(&pDevice);
                if (FAILED(hr)) {
                    continue;
                }

                // Get the name of the emulator
                hr = pDevice->get_Name(&deviceName);
                if (FAILED(hr)){
                    continue;
                }

                // If the name of the device matches the supplied name,
                // then this is the device we are looking for.
                if (deviceIdentifier == deviceName){
                    *pDeviceVMID = pDevice;
                    (*pDeviceVMID)->AddRef();
                    return TRUE;
                }
            }
        }
    }
    wprintf_s(L"Error: Unable to locate the device '%s'", deviceIdentifier);
    return FALSE;
}

要求

DEMComInterface.tlb


IDeviceEmulatorManagerVMID::Shutdown

[image]

设备仿真程序
IDeviceEmulatorManagerVMID::Shutdown
示例

关闭仿真程序，并（可选）保存仿真程序的状态。

HRESULT Shutdown([in] BOOL bSaveState);

参数

[in] bSaveState

指示在退出前是否保存仿真程序的状态。如果为 true，设备仿真程序将在退出之前将仿真程序的当前状态保存在一个 .dess 文件中。

返回值

一个指示方法调用结果的 HRESULT 值。

备注

设备仿真程序的保存状态文件位于 驱动器:\Users\(user)\AppData\Roaming\Microsoft\Device Emulator 下。

这相当于在“设备仿真器管理器”窗口中的“操作”菜单中选择“关闭”。

示例

下面的示例将使用 IDeviceEmulatorManagerVMID 启动 Pocket PC 2003 仿真程序并执行多种操作。

“复制”图像 复制代码
BOOL FindDevice(const CComBSTR& deviceIdentifier, IDeviceEmulatorManagerVMID** pDeviceVMID);

int _tmain(int argc, _TCHAR* argv[])
{
    if (SUCCEEDED(CoInitializeEx(NULL, COINIT_MULTITHREADED)))
    {
        HRESULT hr;
        CComPtr<IDeviceEmulatorManagerVMID> pDevice = NULL;

        // Get the emulator by calling a helper function
        hr = FindDevice("Pocket PC 2003 SE Emulator", &pDevice);

        // If the emulator is found
        if (SUCCEEDED(hr))
        {
            CComBSTR VMID;
            CComBSTR deviceName;
            EMULATOR_STATE deviceState = EMU_NOT_RUNNING;

            // Output the name of the emulator
            hr = pDevice->get_Name(&deviceName);
            if (SUCCEEDED(hr)) wprintf_s(L"Device Name: %s\n", deviceName);

            // Output the emulator's VMID
            hr = pDevice->get_VMID(&VMID);
            if (SUCCEEDED(hr)) wprintf_s(L"Device VMID: %s\n", VMID);

            // Output the emulator's current state
            hr = pDevice->get_State(&deviceState);
            if (SUCCEEDED(hr))
            {
                if (deviceState == EMU_CRADLED) wprintf_s(L"Emulator is Cradled\n");
                else if (deviceState == EMU_RUNNING) wprintf_s(L"Emulator is Running\n");
                else wprintf_s(L"Emulator is Not Running\n");
            }

            // Connect to the emulator
            hr = pDevice->Connect();
            if (SUCCEEDED(hr)) wprintf_s(L"Emulator is connected\n");

            // Make the Device Emulator window visible
            hr = pDevice->BringToFront();
            if (SUCCEEDED(hr)) wprintf_s(L"Device Emulator window is on top\n");

            // Cradle the emulator
            hr = pDevice->Cradle();
            if (SUCCEEDED(hr)) wprintf_s(L"Emulator is cradled\n");

            system("pause");

            // Uncradle the emulator
            hr = pDevice->UnCradle();
            if (SUCCEEDED(hr)) wprintf_s(L"Emulator is uncradled\n");

            // Save state and shutdown the emulator
            hr = pDevice->Shutdown(true);
            if (SUCCEEDED(hr)) wprintf_s(L"Emulator is shutdown\n");

            // Delete the .dess save state file for this device
            hr = pDevice->ClearSaveState();
            if (SUCCEEDED(hr)) wprintf_s(L"Save state file is deleted");

            system("pause");
        }
    }
    return 0;
}

// Helper method to find a device given name or VMID
BOOL FindDevice(const CComBSTR& deviceIdentifier, IDeviceEmulatorManagerVMID** pDeviceVMID)
{
    HRESULT hr;

    // Instantiate DeviceEmulatorManager (DEM) object.
    //  This starts DvcEmuManager.exe in silent mode
    CComPtr<IDeviceEmulatorManager> pDeviceEmulatorManager;
    hr = pDeviceEmulatorManager.CoCreateInstance(__uuidof(DeviceEmulatorManager));
    if (FAILED(hr)) {
        wprintf_s(L"Error: Unable to instantiate DeviceEmulatorManager. ErrorCode=0x%08X\n", hr);
        return FALSE;
    }

    // For each of the four nodes in the Device Emulator Manager window
    // (Datastore, My Device Emulators, All Device Emulators, and Others)
    for (; SUCCEEDED(hr); (hr = pDeviceEmulatorManager->MoveNext()))
    {
        CComPtr<IEnumManagerSDKs> pSDKEnumerator;

        // Get a list of SDKs/platforms in this node
        hr = pDeviceEmulatorManager->EnumerateSDKs(&pSDKEnumerator);
        if (FAILED(hr)) {
            continue;
        }

        // For every SDK/platform in the list
        for (; SUCCEEDED(hr); (hr = pSDKEnumerator->MoveNext()))
        {

            // Get the list of emulators in the SDK/platform
            CComPtr<IEnumVMIDs> pDeviceEnumerator;
            hr = pSDKEnumerator->EnumerateVMIDs(&pDeviceEnumerator);
            if (FAILED(hr)) {
                continue;
            }

            // For every emulator in the list
            for (; SUCCEEDED(hr); (hr = pDeviceEnumerator->MoveNext()))
            {
                CComBSTR deviceName;
                CComPtr<IDeviceEmulatorManagerVMID> pDevice;

                // Get the IDeviceEmulatorManagerVMID object.
                hr = pDeviceEnumerator->GetVMID(&pDevice);
                if (FAILED(hr)) {
                    continue;
                }

                // Get the name of the emulator
                hr = pDevice->get_Name(&deviceName);
                if (FAILED(hr)){
                    continue;
                }

                // If the name of the device matches the supplied name,
                // then this is the device we are looking for.
                if (deviceIdentifier == deviceName){
                    *pDeviceVMID = pDevice;
                    (*pDeviceVMID)->AddRef();
                    return TRUE;
                }
            }
        }
    }
    wprintf_s(L"Error: Unable to locate the device '%s'", deviceIdentifier);
    return FALSE;
}

要求

DEMComInterface.tlb


IDeviceEmulatorManagerVMID::Reset

[image]

设备仿真程序
IDeviceEmulatorManagerVMID::Reset
示例

重置仿真程序。

HRESULT Reset([in] BOOL bSoft);

参数

[in] bSoft

指示仿真程序应执行硬重置还是软重置。如果为 true，则执行软重置。

返回值

一个指示方法调用结果的 HRESULT 值。

备注

这相当于在“设备仿真器管理器”窗口中的“操作”菜单中选择“重置”。

示例

下面的示例将使用 IDeviceEmulatorManagerVMID 启动 Pocket PC 2003 仿真程序并执行多种操作。

“复制”图像 复制代码
BOOL FindDevice(const CComBSTR& deviceIdentifier, IDeviceEmulatorManagerVMID** pDeviceVMID);

int _tmain(int argc, _TCHAR* argv[])
{
    if (SUCCEEDED(CoInitializeEx(NULL, COINIT_MULTITHREADED)))
    {
        // HRESULT is used to determine whether method calls are successful
        HRESULT hr;
        CComPtr<IDeviceEmulatorManagerVMID> pDevice = NULL;

        // Get the emulator by calling a helper function
        hr = FindDevice("Pocket PC 2003 SE Emulator", &pDevice);

        // If the emulator is found
        if (SUCCEEDED(hr))
        {
            // Connect to the emulator
            hr = pDevice->Connect();
            if (SUCCEEDED(hr)) wprintf_s(L"Emulator is connected\n");

            system("pause");

            // Output the Device Emulator's configuration.
            BSTR bstrConfig;
            hr = pDevice->GetConfiguration(&bstrConfig);
            if (SUCCEEDED(hr)) wprintf_s(L"Get the device's configuration\n");
            wprintf_s(bstrConfig);

            system("pause");

            // Insert code here to modify the Device Emulator's configuration XML.

            // Set the Device Emulator's configuration
            hr = pDevice->SetConfiguration(bstrConfig);
            if (!SUCCEEDED(hr)) wprintf_s(L"Set the device's configuration\n");
            system("pause");

            // Perform a soft reset
            hr = pDevice->Reset(true);
            if (SUCCEEDED(hr)) wprintf_s(L"Resetting the device\n");
        }
    }
    return 0;
}

// Helper method to find a device given name or VMID
BOOL FindDevice(const CComBSTR& deviceIdentifier, IDeviceEmulatorManagerVMID** pDeviceVMID)
{
    HRESULT hr;

    // Instantiate DeviceEmulatorManager (DEM) object.
    //  This starts DvcEmuManager.exe in silent mode
    CComPtr<IDeviceEmulatorManager> pDeviceEmulatorManager;
    hr = pDeviceEmulatorManager.CoCreateInstance(__uuidof(DeviceEmulatorManager));
    if (FAILED(hr)) {
        wprintf_s(L"Error: Unable to instantiate DeviceEmulatorManager. ErrorCode=0x%08X\n", hr);
        return FALSE;
    }

    // For each of the four nodes in the Device Emulator Manager window
    // (Datastore, My Device Emulators, All Device Emulators, and Others)
    for (; SUCCEEDED(hr); (hr = pDeviceEmulatorManager->MoveNext()))
    {
        CComPtr<IEnumManagerSDKs> pSDKEnumerator;

        // Get a list of SDKs/platforms in this node
        hr = pDeviceEmulatorManager->EnumerateSDKs(&pSDKEnumerator);
        if (FAILED(hr)) {
            continue;
        }
        // For every SDK/platform in the list
        for (; SUCCEEDED(hr); (hr = pSDKEnumerator->MoveNext()))
        {
            // Get the list of emulators in the SDK/platform
            CComPtr<IEnumVMIDs> pDeviceEnumerator;
            hr = pSDKEnumerator->EnumerateVMIDs(&pDeviceEnumerator);
            if (FAILED(hr)) {
                continue;
            }
            // For every emulator in the list
            for (; SUCCEEDED(hr); (hr = pDeviceEnumerator->MoveNext()))
            {
                CComBSTR deviceName;
                CComPtr<IDeviceEmulatorManagerVMID> pDevice;

                // Get the IDeviceEmulatorManagerVMID object.
                hr = pDeviceEnumerator->GetVMID(&pDevice);
                if (FAILED(hr)) {
                    continue;
                }

                // Get the name of the emulator
                hr = pDevice->get_Name(&deviceName);
                if (FAILED(hr)){
                    continue;
                }

                // If the name of the device matches the supplied name,
                // then this is the device we are looking for.
                if (deviceIdentifier == deviceName){
                    *pDeviceVMID = pDevice;
                    (*pDeviceVMID)->AddRef();
                    return TRUE;
                }
            }
        }
    }
    wprintf_s(L"Error: Unable to locate the device '%s'", deviceIdentifier);
    return FALSE;
}

要求

DEMComInterface.tlb


IDeviceEmulatorManagerVMID::ClearSaveState

[image]

设备仿真程序
IDeviceEmulatorManagerVMID::ClearSaveState
示例

清除与此设备关联的设备仿真程序保存状态文件 (.dess)。下次启动时，仿真程序将从其 ROM 映像而非其保存状态文件启动。

HRESULT ClearSaveState();

返回值

一个指示方法调用结果的 HRESULT 值。

备注

设备仿真程序的保存状态文件位于 驱动器:\Users\（用户）\AppData\Roaming\Microsoft\Device Emulator 下。

这相当于在“设备仿真器管理器”窗口中的“操作”菜单中选择“清除保存状态”。

示例

下面的示例将使用 IDeviceEmulatorManagerVMID 启动 Pocket PC 2003 仿真程序并执行多种操作。

“复制”图像 复制代码
BOOL FindDevice(const CComBSTR& deviceIdentifier, IDeviceEmulatorManagerVMID** pDeviceVMID);

int _tmain(int argc, _TCHAR* argv[])
{
    if (SUCCEEDED(CoInitializeEx(NULL, COINIT_MULTITHREADED)))
    {
        HRESULT hr;
        CComPtr<IDeviceEmulatorManagerVMID> pDevice = NULL;

        // Get the emulator by calling a helper function
        hr = FindDevice("Pocket PC 2003 SE Emulator", &pDevice);

        // If the emulator is found
        if (SUCCEEDED(hr))
        {
            CComBSTR VMID;
            CComBSTR deviceName;
            EMULATOR_STATE deviceState = EMU_NOT_RUNNING;

            // Output the name of the emulator
            hr = pDevice->get_Name(&deviceName);
            if (SUCCEEDED(hr)) wprintf_s(L"Device Name: %s\n", deviceName);

            // Output the emulator's VMID
            hr = pDevice->get_VMID(&VMID);
            if (SUCCEEDED(hr)) wprintf_s(L"Device VMID: %s\n", VMID);

            // Output the emulator's current state
            hr = pDevice->get_State(&deviceState);
            if (SUCCEEDED(hr))
            {
                if (deviceState == EMU_CRADLED) wprintf_s(L"Emulator is Cradled\n");
                else if (deviceState == EMU_RUNNING) wprintf_s(L"Emulator is Running\n");
                else wprintf_s(L"Emulator is Not Running\n");
            }

            // Connect to the emulator
            hr = pDevice->Connect();
            if (SUCCEEDED(hr)) wprintf_s(L"Emulator is connected\n");

            // Make the Device Emulator window visible
            hr = pDevice->BringToFront();
            if (SUCCEEDED(hr)) wprintf_s(L"Device Emulator window is on top\n");

            // Cradle the emulator
            hr = pDevice->Cradle();
            if (SUCCEEDED(hr)) wprintf_s(L"Emulator is cradled\n");

            system("pause");

            // Uncradle the emulator
            hr = pDevice->UnCradle();
            if (SUCCEEDED(hr)) wprintf_s(L"Emulator is uncradled\n");

            // Save state and shutdown the emulator
            hr = pDevice->Shutdown(true);
            if (SUCCEEDED(hr)) wprintf_s(L"Emulator is shutdown\n");

            // Delete the .dess save state file for this device
            hr = pDevice->ClearSaveState();
            if (SUCCEEDED(hr)) wprintf_s(L"Save state file is deleted");

            system("pause");
        }
    }
    return 0;
}

// Helper method to find a device given name or VMID
BOOL FindDevice(const CComBSTR& deviceIdentifier, IDeviceEmulatorManagerVMID** pDeviceVMID)
{
    HRESULT hr;

    // Instantiate DeviceEmulatorManager (DEM) object.
    //  This starts DvcEmuManager.exe in silent mode
    CComPtr<IDeviceEmulatorManager> pDeviceEmulatorManager;
    hr = pDeviceEmulatorManager.CoCreateInstance(__uuidof(DeviceEmulatorManager));
    if (FAILED(hr)) {
        wprintf_s(L"Error: Unable to instantiate DeviceEmulatorManager. ErrorCode=0x%08X\n", hr);
        return FALSE;
    }

    // For each of the four nodes in the Device Emulator Manager window
    // (Datastore, My Device Emulators, All Device Emulators, and Others)
    for (; SUCCEEDED(hr); (hr = pDeviceEmulatorManager->MoveNext()))
    {
        CComPtr<IEnumManagerSDKs> pSDKEnumerator;

        // Get a list of SDKs/platforms in this node
        hr = pDeviceEmulatorManager->EnumerateSDKs(&pSDKEnumerator);
        if (FAILED(hr)) {
            continue;
        }

        // For every SDK/platform in the list
        for (; SUCCEEDED(hr); (hr = pSDKEnumerator->MoveNext()))
        {

            // Get the list of emulators in the SDK/platform
            CComPtr<IEnumVMIDs> pDeviceEnumerator;
            hr = pSDKEnumerator->EnumerateVMIDs(&pDeviceEnumerator);
            if (FAILED(hr)) {
                continue;
            }

            // For every emulator in the list
            for (; SUCCEEDED(hr); (hr = pDeviceEnumerator->MoveNext()))
            {
                CComBSTR deviceName;
                CComPtr<IDeviceEmulatorManagerVMID> pDevice;

                // Get the IDeviceEmulatorManagerVMID object.
                hr = pDeviceEnumerator->GetVMID(&pDevice);
                if (FAILED(hr)) {
                    continue;
                }

                // Get the name of the emulator
                hr = pDevice->get_Name(&deviceName);
                if (FAILED(hr)){
                    continue;
                }

                // If the name of the device matches the supplied name,
                // then this is the device we are looking for.
                if (deviceIdentifier == deviceName){
                    *pDeviceVMID = pDevice;
                    (*pDeviceVMID)->AddRef();
                    return TRUE;
                }
            }
        }
    }
    wprintf_s(L"Error: Unable to locate the device '%s'", deviceIdentifier);
    return FALSE;
}

要求

DEMComInterface.tlb


IDeviceEmulatorManagerVMID::BringToFront

[image]

设备仿真程序
IDeviceEmulatorManagerVMID::BringToFront
示例

显示“设备仿真程序”窗口。

HRESULT BringToFront();

返回值

一个指示方法调用结果的 HRESULT 值。

备注

这相当于在“设备仿真器管理器”窗口中的“操作”菜单中选择“置于顶层”。

示例

下面的示例将使用 IDeviceEmulatorManagerVMID 启动 Pocket PC 2003 仿真程序并执行多种操作。

“复制”图像 复制代码
BOOL FindDevice(const CComBSTR& deviceIdentifier, IDeviceEmulatorManagerVMID** pDeviceVMID);

int _tmain(int argc, _TCHAR* argv[])
{
    if (SUCCEEDED(CoInitializeEx(NULL, COINIT_MULTITHREADED)))
    {
        HRESULT hr;
        CComPtr<IDeviceEmulatorManagerVMID> pDevice = NULL;

        // Get the emulator by calling a helper function
        hr = FindDevice("Pocket PC 2003 SE Emulator", &pDevice);

        // If the emulator is found
        if (SUCCEEDED(hr))
        {
            CComBSTR VMID;
            CComBSTR deviceName;
            EMULATOR_STATE deviceState = EMU_NOT_RUNNING;

            // Output the name of the emulator
            hr = pDevice->get_Name(&deviceName);
            if (SUCCEEDED(hr)) wprintf_s(L"Device Name: %s\n", deviceName);

            // Output the emulator's VMID
            hr = pDevice->get_VMID(&VMID);
            if (SUCCEEDED(hr)) wprintf_s(L"Device VMID: %s\n", VMID);

            // Output the emulator's current state
            hr = pDevice->get_State(&deviceState);
            if (SUCCEEDED(hr))
            {
                if (deviceState == EMU_CRADLED) wprintf_s(L"Emulator is Cradled\n");
                else if (deviceState == EMU_RUNNING) wprintf_s(L"Emulator is Running\n");
                else wprintf_s(L"Emulator is Not Running\n");
            }

            // Connect to the emulator
            hr = pDevice->Connect();
            if (SUCCEEDED(hr)) wprintf_s(L"Emulator is connected\n");

            // Make the Device Emulator window visible
            hr = pDevice->BringToFront();
            if (SUCCEEDED(hr)) wprintf_s(L"Device Emulator window is on top\n");

            // Cradle the emulator
            hr = pDevice->Cradle();
            if (SUCCEEDED(hr)) wprintf_s(L"Emulator is cradled\n");

            system("pause");

            // Uncradle the emulator
            hr = pDevice->UnCradle();
            if (SUCCEEDED(hr)) wprintf_s(L"Emulator is uncradled\n");

            // Save state and shutdown the emulator
            hr = pDevice->Shutdown(true);
            if (SUCCEEDED(hr)) wprintf_s(L"Emulator is shutdown\n");

            // Delete the .dess save state file for this device
            hr = pDevice->ClearSaveState();
            if (SUCCEEDED(hr)) wprintf_s(L"Save state file is deleted");

            system("pause");
        }
    }
    return 0;
}

// Helper method to find a device given name or VMID
BOOL FindDevice(const CComBSTR& deviceIdentifier, IDeviceEmulatorManagerVMID** pDeviceVMID)
{
    HRESULT hr;

    // Instantiate DeviceEmulatorManager (DEM) object.
    //  This starts DvcEmuManager.exe in silent mode
    CComPtr<IDeviceEmulatorManager> pDeviceEmulatorManager;
    hr = pDeviceEmulatorManager.CoCreateInstance(__uuidof(DeviceEmulatorManager));
    if (FAILED(hr)) {
        wprintf_s(L"Error: Unable to instantiate DeviceEmulatorManager. ErrorCode=0x%08X\n", hr);
        return FALSE;
    }

    // For each of the four nodes in the Device Emulator Manager window
    // (Datastore, My Device Emulators, All Device Emulators, and Others)
    for (; SUCCEEDED(hr); (hr = pDeviceEmulatorManager->MoveNext()))
    {
        CComPtr<IEnumManagerSDKs> pSDKEnumerator;

        // Get a list of SDKs/platforms in this node
        hr = pDeviceEmulatorManager->EnumerateSDKs(&pSDKEnumerator);
        if (FAILED(hr)) {
            continue;
        }

        // For every SDK/platform in the list
        for (; SUCCEEDED(hr); (hr = pSDKEnumerator->MoveNext()))
        {

            // Get the list of emulators in the SDK/platform
            CComPtr<IEnumVMIDs> pDeviceEnumerator;
            hr = pSDKEnumerator->EnumerateVMIDs(&pDeviceEnumerator);
            if (FAILED(hr)) {
                continue;
            }

            // For every emulator in the list
            for (; SUCCEEDED(hr); (hr = pDeviceEnumerator->MoveNext()))
            {
                CComBSTR deviceName;
                CComPtr<IDeviceEmulatorManagerVMID> pDevice;

                // Get the IDeviceEmulatorManagerVMID object.
                hr = pDeviceEnumerator->GetVMID(&pDevice);
                if (FAILED(hr)) {
                    continue;
                }

                // Get the name of the emulator
                hr = pDevice->get_Name(&deviceName);
                if (FAILED(hr)){
                    continue;
                }

                // If the name of the device matches the supplied name,
                // then this is the device we are looking for.
                if (deviceIdentifier == deviceName){
                    *pDeviceVMID = pDevice;
                    (*pDeviceVMID)->AddRef();
                    return TRUE;
                }
            }
        }
    }
    wprintf_s(L"Error: Unable to locate the device '%s'", deviceIdentifier);
    return FALSE;
}

要求

DEMComInterface.tlb


IDeviceEmulatorManagerVMID::GetConfiguration

[image]

设备仿真程序
IDeviceEmulatorManagerVMID::GetConfiguration
示例

以设备仿真程序配置 XML 格式获取仿真程序的配置。

HRESULT GetConfiguration([out, retval] BSTR *lpbstrConfig);

参数

[out, retvan] lpbstrConfig

一个指针，它指向包含仿真程序配置的字符串。

返回值

一个指示方法调用结果的 HRESULT 值。

备注

输出的格式与设备仿真程序配置文件中的格式相同。有关更多信息，请参见设备仿真程序配置 XML 架构参考。

示例

下面的示例将使用 IDeviceEmulatorManagerVMID 启动 Pocket PC 2003 仿真程序并执行多种操作。

“复制”图像 复制代码
BOOL FindDevice(const CComBSTR& deviceIdentifier, IDeviceEmulatorManagerVMID** pDeviceVMID);

int _tmain(int argc, _TCHAR* argv[])
{
    if (SUCCEEDED(CoInitializeEx(NULL, COINIT_MULTITHREADED)))
    {
        // HRESULT is used to determine whether method calls are successful
        HRESULT hr;
        CComPtr<IDeviceEmulatorManagerVMID> pDevice = NULL;

        // Get the emulator by calling a helper function
        hr = FindDevice("Pocket PC 2003 SE Emulator", &pDevice);

        // If the emulator is found
        if (SUCCEEDED(hr))
        {
            // Connect to the emulator
            hr = pDevice->Connect();
            if (SUCCEEDED(hr)) wprintf_s(L"Emulator is connected\n");

            system("pause");

            // Output the Device Emulator's configuration.
            BSTR bstrConfig;
            hr = pDevice->GetConfiguration(&bstrConfig);
            if (SUCCEEDED(hr)) wprintf_s(L"Get the device's configuration\n");
            wprintf_s(bstrConfig);

            system("pause");

            // Insert code here to modify the Device Emulator's configuration XML.

            // Set the Device Emulator's configuration
            hr = pDevice->SetConfiguration(bstrConfig);
            if (!SUCCEEDED(hr)) wprintf_s(L"Set the device's configuration\n");
            system("pause");

            // Perform a soft reset
            hr = pDevice->Reset(true);
            if (SUCCEEDED(hr)) wprintf_s(L"Resetting the device\n");
        }
    }
    return 0;
}

// Helper method to find a device given name or VMID
BOOL FindDevice(const CComBSTR& deviceIdentifier, IDeviceEmulatorManagerVMID** pDeviceVMID)
{
    HRESULT hr;

    // Instantiate DeviceEmulatorManager (DEM) object.
    //  This starts DvcEmuManager.exe in silent mode
    CComPtr<IDeviceEmulatorManager> pDeviceEmulatorManager;
    hr = pDeviceEmulatorManager.CoCreateInstance(__uuidof(DeviceEmulatorManager));
    if (FAILED(hr)) {
        wprintf_s(L"Error: Unable to instantiate DeviceEmulatorManager. ErrorCode=0x%08X\n", hr);
        return FALSE;
    }

    // For each of the four nodes in the Device Emulator Manager window
    // (Datastore, My Device Emulators, All Device Emulators, and Others)
    for (; SUCCEEDED(hr); (hr = pDeviceEmulatorManager->MoveNext()))
    {
        CComPtr<IEnumManagerSDKs> pSDKEnumerator;

        // Get a list of SDKs/platforms in this node
        hr = pDeviceEmulatorManager->EnumerateSDKs(&pSDKEnumerator);
        if (FAILED(hr)) {
            continue;
        }
        // For every SDK/platform in the list
        for (; SUCCEEDED(hr); (hr = pSDKEnumerator->MoveNext()))
        {
            // Get the list of emulators in the SDK/platform
            CComPtr<IEnumVMIDs> pDeviceEnumerator;
            hr = pSDKEnumerator->EnumerateVMIDs(&pDeviceEnumerator);
            if (FAILED(hr)) {
                continue;
            }
            // For every emulator in the list
            for (; SUCCEEDED(hr); (hr = pDeviceEnumerator->MoveNext()))
            {
                CComBSTR deviceName;
                CComPtr<IDeviceEmulatorManagerVMID> pDevice;

                // Get the IDeviceEmulatorManagerVMID object.
                hr = pDeviceEnumerator->GetVMID(&pDevice);
                if (FAILED(hr)) {
                    continue;
                }

                // Get the name of the emulator
                hr = pDevice->get_Name(&deviceName);
                if (FAILED(hr)){
                    continue;
                }

                // If the name of the device matches the supplied name,
                // then this is the device we are looking for.
                if (deviceIdentifier == deviceName){
                    *pDeviceVMID = pDevice;
                    (*pDeviceVMID)->AddRef();
                    return TRUE;
                }
            }
        }
    }
    wprintf_s(L"Error: Unable to locate the device '%s'", deviceIdentifier);
    return FALSE;
}

要求

DEMComInterface.tlb


IDeviceEmulatorManagerVMID::SetConfiguration

[image]

设备仿真程序
IDeviceEmulatorManagerVMID::SetConfiguration
示例

在给定正确格式化的设备仿真程序配置 XML 字符串时设置仿真程序的配置。

HRESULT SetConfiguration([in] const BSTR bstrConfig);

参数

[in] bstrConfig

一个字符串，它包含要应用于仿真程序的配置设置。

返回值

一个指示方法调用结果的 HRESULT 值。

备注

输入的格式必须遵循设备仿真程序配置文件的格式。有关更多信息，请参见设备仿真程序配置 XML 架构参考。

安全说明 安全说明：

如果将仿真程序的闪存或共享文件夹配置为指向不受信任的远程位置，则可能会执行不受信任的代码。

示例

下面的示例将使用 IDeviceEmulatorManagerVMID 启动 Pocket PC 2003 仿真程序并执行多种操作。

“复制”图像 复制代码
BOOL FindDevice(const CComBSTR& deviceIdentifier, IDeviceEmulatorManagerVMID** pDeviceVMID);

int _tmain(int argc, _TCHAR* argv[])
{
    if (SUCCEEDED(CoInitializeEx(NULL, COINIT_MULTITHREADED)))
    {
        // HRESULT is used to determine whether method calls are successful
        HRESULT hr;
        CComPtr<IDeviceEmulatorManagerVMID> pDevice = NULL;

        // Get the emulator by calling a helper function
        hr = FindDevice("Pocket PC 2003 SE Emulator", &pDevice);

        // If the emulator is found
        if (SUCCEEDED(hr))
        {
            // Connect to the emulator
            hr = pDevice->Connect();
            if (SUCCEEDED(hr)) wprintf_s(L"Emulator is connected\n");

            system("pause");

            // Output the Device Emulator's configuration.
            BSTR bstrConfig;
            hr = pDevice->GetConfiguration(&bstrConfig);
            if (SUCCEEDED(hr)) wprintf_s(L"Get the device's configuration\n");
            wprintf_s(bstrConfig);

            system("pause");

            // Insert code here to modify the Device Emulator's configuration XML.

            // Set the Device Emulator's configuration
            hr = pDevice->SetConfiguration(bstrConfig);
            if (!SUCCEEDED(hr)) wprintf_s(L"Set the device's configuration\n");
            system("pause");

            // Perform a soft reset
            hr = pDevice->Reset(true);
            if (SUCCEEDED(hr)) wprintf_s(L"Resetting the device\n");
        }
    }
    return 0;
}

// Helper method to find a device given name or VMID
BOOL FindDevice(const CComBSTR& deviceIdentifier, IDeviceEmulatorManagerVMID** pDeviceVMID)
{
    HRESULT hr;

    // Instantiate DeviceEmulatorManager (DEM) object.
    //  This starts DvcEmuManager.exe in silent mode
    CComPtr<IDeviceEmulatorManager> pDeviceEmulatorManager;
    hr = pDeviceEmulatorManager.CoCreateInstance(__uuidof(DeviceEmulatorManager));
    if (FAILED(hr)) {
        wprintf_s(L"Error: Unable to instantiate DeviceEmulatorManager. ErrorCode=0x%08X\n", hr);
        return FALSE;
    }

    // For each of the four nodes in the Device Emulator Manager window
    // (Datastore, My Device Emulators, All Device Emulators, and Others)
    for (; SUCCEEDED(hr); (hr = pDeviceEmulatorManager->MoveNext()))
    {
        CComPtr<IEnumManagerSDKs> pSDKEnumerator;

        // Get a list of SDKs/platforms in this node
        hr = pDeviceEmulatorManager->EnumerateSDKs(&pSDKEnumerator);
        if (FAILED(hr)) {
            continue;
        }
        // For every SDK/platform in the list
        for (; SUCCEEDED(hr); (hr = pSDKEnumerator->MoveNext()))
        {
            // Get the list of emulators in the SDK/platform
            CComPtr<IEnumVMIDs> pDeviceEnumerator;
            hr = pSDKEnumerator->EnumerateVMIDs(&pDeviceEnumerator);
            if (FAILED(hr)) {
                continue;
            }
            // For every emulator in the list
            for (; SUCCEEDED(hr); (hr = pDeviceEnumerator->MoveNext()))
            {
                CComBSTR deviceName;
                CComPtr<IDeviceEmulatorManagerVMID> pDevice;

                // Get the IDeviceEmulatorManagerVMID object.
                hr = pDeviceEnumerator->GetVMID(&pDevice);
                if (FAILED(hr)) {
                    continue;
                }

                // Get the name of the emulator
                hr = pDevice->get_Name(&deviceName);
                if (FAILED(hr)){
                    continue;
                }

                // If the name of the device matches the supplied name,
                // then this is the device we are looking for.
                if (deviceIdentifier == deviceName){
                    *pDeviceVMID = pDevice;
                    (*pDeviceVMID)->AddRef();
                    return TRUE;
                }
            }
        }
    }
    wprintf_s(L"Error: Unable to locate the device '%s'", deviceIdentifier);
    return FALSE;
}

要求

DEMComInterface.tlb


EMULATOR_STATE

[image]

设备仿真程序
EMULATOR_STATE
请参见

指示仿真程序的状态。

enum EMULATOR_STATE
{
    EMU_NOT_RUNNING = 0,
    EMU_RUNNING = 1,
    EMU_CRADLED = 2
}

备注

IDeviceEmulatorManagerVMID::get_State 使用此枚举。仿真程序的状态可以是未在运行、正在运行或已插入底座。

要求

DEMComInterface.tlb

请参见

其他资源

Device Emulator samples（设备仿真程序示例）


设备仿真程序外观 XML 架构参考

[image]

设备仿真程序
设备仿真程序外观 XML 架构参考
请参见

下列参考资料可作为开发设备仿真程序的自定义外观文件的模型。

注意 注意：

可以使用 PNG 和 BMP 图像文件。

代码

“复制”图像 复制代码
<?xml version="1.0" encoding="ISO-8859-1"?>

<skin>
    <view
        titleBar ="My Emulator skin"
        displayPosX="10"
        displayPosY="149"
        displayWidth="272"
        displayHeight="224"
        displayDepth="8"
        mappingImage="map.bmp"
        normalImage="up.bmp"
        downImage="down.bmp"

        <button
            toolTip="This is my ToolTip."
            onClick="  DOWN:Key_LeftShift
                       Key_Z
                       0x00000015
                       UP: Key_LeftShift
                       Key_A"
            onPressAndHold="Key_B"
            mappingColor="0x00FF00"
        />
    </view>
</skin>

备注

项 | 说明
<skin> 标记 | 封装仿真程序外观的架构。每个 .xml 文件中只能使用一个 <skin> 标记。
<view> 标记 | 包含仿真程序外观的架构。每个 <skin> 标记只能使用一个 <view>。
titleBar ="My Emulator skin" 标题栏元素 | 指定仿真程序的窗口标题。
displayPosX="10" 和 displayPosY="149" 元素 | 指定用来定位仿真程序外观窗口中包含仿真程序显示屏的窗口的位置。若要使该显示屏不可见，请选择屏幕范围以外的坐标。
displayWidth="272" 和 displayHeight="224" 元素 | 指定仿真程序显示屏的宽度和高度。对于宽度，选择一个介于 80 和 1024 之间而且是 8 的倍数的整数。对于高度，选择一个介于 64 和 768 之间的整数。
displayDepth="8" 元素 | 指定仿真程序的显示屏的颜色深度。对于颜色深度，选择 8、16 或 32。
normalImage="up.bmp" 元素 | 指定仿真程序外观的标准图形文件，这是一个必需的元素。标准图片文件用于指定仿真程序窗口的大小，以及仿真程序外观的外貌。
mappingImage="map.bmp" 元素 | 指定仿真程序外观的映射文件。映射文件是一种可选文件，用于定义仿真程序外观中被按钮占用的区域。
downImage="down.bmp" 元素 | 为仿真程序外观指定按下图形文件。按下图形文件是一个可选文件，它指定按下按钮时按钮在仿真程序外观中的显示。
<button> 标记 | 包含对仿真程序外观上某个按钮的说明。
mappingColor="0x00FF00" 元素 | 在映射文件中指定按钮要用的 RGB 颜色。映射图像中具有此颜色的所有像素都表示仿真程序外观中可以为此按钮单击的区域。此区域可以用作屏蔽。在按下该按钮时，通过该屏蔽将显示按下按钮时的图片文件。
toolTip="This is my ToolTip." 元素 | 可选。指定指针移动到按钮上方时显示的文本。
onClick=" DOWN:Key_LeftShift Key_Z 0x00000015 UP: Key_LeftShift Key_A" | 可选。指定按下按钮时要传递给引擎的键盘按键操作。使用与原始键盘扫描代码对应的十六进制或整数值。
onPressAndHold="Key_B" 元素 | 指定在按下仿真程序外观上某个按钮的同时要重复的键盘事件。此功能支持所有的键代码，但 Shutdown 键代码除外。

请参见

概念

如何：自定义仿真程序的外观
外观
设备仿真程序参考


设备仿真程序组合键

[image]

设备仿真程序
设备仿真程序组合键
请参见

使用开发计算机的键盘可以控制在运行时在设备仿真程序上执行的某些操作。

有关查看或更改主机键的更多信息，请参见 如何：指定主机键。

操作 | 组合键
关机 | 主机键+F4
显示“文件”菜单 | 主机键+Alt+F
显示“帮助”菜单 | 主机键+Alt+H
显示快捷菜单 | 主机键+Alt+空格键

请参见

概念

设备仿真程序参考


设备仿真程序用户界面参考

[image]

设备仿真程序
设备仿真程序用户界面参考
请参见

本节介绍用于设置设备仿真程序的各个选项的用户界面元素。

注意 注意：

“设备仿真程序管理器”对话框仅在 Visual Studio 环境中提供。

本节内容

“仿真程序属性”对话框 ->“显示”

用于更改高度、宽度和方向等显示特性。

“仿真程序属性”对话框 ->“常规”

用于指定操作系统图像、执行开始时的 ROM 地址和闪存文件等基本选项。

“仿真程序属性”对话框 ->“网络”

用于将虚拟网络适配器绑定到主机上的实际网卡。

“仿真程序属性”对话框 ->“外围设备”

用于更改通过串行端口连接的外围设备的设置。

“设备仿真程序管理器”对话框

列出可用的仿真程序并提供与它们的连接。

请参见

概念

设备仿真程序


“仿真程序属性”对话框 ->“显示”

[image]

设备仿真程序
“仿真程序属性”对话框 ->“显示”
请参见

使用此选项卡可以指定仿真程序的外观特征。

如何显示此选项卡式对话框取决于您的安装。有关更多信息，请参见如何：更改属性设置。

仅可以在冷启动该仿真程序之前指定屏幕大小和颜色深度。即，无法在运行时更改这些属性。

使用不同的屏幕大小会导致仿真程序失常。推荐采用以下屏幕大小：

设备 | 屏幕大小
PocketPC | 240x320
PocketPC VGA | 480x640
Smartphone | 176x220
SmartPhone QVGA | 240x320
外观

如果选择“外观”，则单击省略号按钮（“…”）定位外观文件。如果不想显示外观，则选择“视频”。如果选择“视频”，则必须完成所有视频设置。

有关外观的更多信息，请参见 Windows CE 文档中的 Emulator Skin（仿真程序外观）。

屏幕宽度

最小宽度为 64 像素，最大为 800。此数必须为偶数。

屏幕高度

最小高度为 64 像素，最大为 800。此数必须为偶数。

颜色深度

从下拉列表中选择 8 的倍数。

方向

指定 0、90、180 或 270 度的方向。您可以在运行时更改该值。当来宾 OS 从纵向模式切换到横向模式时，该仿真程序将自动更改方向。

有关更多信息，请参见 SDK 文档。

放大 2 倍

在各轴上拉伸外观，会得到四倍于原始大小的图像。可以在运行时更改此设置。

总在最前面

在开发环境中将仿真程序保持在 z 顺序的顶层。可以在运行时更改此设置。

启用工具提示

悬停在任何菜单或按钮之上将显示工具提示。仅在使用了外观文件并在该文件中定义了工具提示时才能使用此功能。

请参见

概念

如何：更改属性设置
设备仿真程序用户界面参考
“仿真程序属性”对话框 ->“常规”
“仿真程序属性”对话框 ->“网络”
“仿真程序属性”对话框 ->“外围设备”


“仿真程序属性”对话框 ->“常规”

[image]

设备仿真程序
“仿真程序属性”对话框 ->“常规”
请参见

使用此选项卡可以设置仿真程序本身的属性，例如要加载的内核映像等。

如何显示此选项卡式对话框取决于您的安装。有关更多信息，请参见如何：更改属性设置。

OS 映像名称

指定内核映像的名称。

单击省略号按钮打开一个文件对话框，可在此对话框中选择 .bin 或 .nb0（OS ROM 映像）文件。

如果仿真程序已启动，则此字段为只读。若要更改映像文件，必须重新启动仿真程序。

安全说明 安全说明：

使用来自不受信任来源的保存状态文件会导致安全风险。

指定 ROM 映像地址

指定 ROM 映像内的一个十六进制地址，将由此开始执行。当使用自定义映像时，此功能非常有用。

如果想更改地址，必须重新启动仿真程序以使更改生效。

指定 RAM 大小

设置内存的大小，单位为 MB。默认值为 64 MB。

如果想更改 RAM 大小，必须重新启动仿真程序以使更改生效。

闪存文件

（在运行时是只读的。）指定包含已保存的 NAND 闪存映像的文件。如果该文件不存在，则将使用空白格式化的映像对该闪存进行初始化。可以通过使用仿真程序上的“闪存/保存”菜单来保存 NAND 闪存的状态。

多个 OS 映像可以使用同一个闪存文件。

只能从冷启动方式下初始化 NAND 闪存状态。因此，保存的状态文件之内包含 NAND 闪存的当前状态。

注意 注意：

并非所有 SDK 都支持 NAND 闪存。当不支持 NAND 闪存时，“闪存”菜单上的“保存”命令不可用。

主机键

指定用于向主机操作系统发送组合键的键，例如 Alt+Tab。

功能键

这是一个特殊的开关，其值通常为 193。值 193 会将键盘功能键（F1、F2 等）映射到设备仿真程序的软键。

共享文件夹

指定要装载为共享文件夹的目录。

请参见

概念

设备仿真程序用户界面参考
“仿真程序属性”对话框 ->“显示”
“仿真程序属性”对话框 ->“网络”
“仿真程序属性”对话框 ->“外围设备”


“仿真程序属性”对话框 ->“网络”

[image]

设备仿真程序
“仿真程序属性”对话框 ->“网络”
请参见

使用此选项卡可以将虚拟网络适配器绑定到主机系统上的真实网卡。

如何显示此选项卡式对话框取决于您的安装。有关更多信息，请参见如何：更改属性设置。

如果开发计算机没有网络连接，则请安装 Microsoft Loopback Adapter，选择 Loopback Adapter 网卡，再选择“仅主机网络”。有关更多信息，请参见 MSDN Online Library 中的“Installing the Microsoft Loopback Adapter”（安装 Microsoft Loopback Adapter）。

启用 NE2000 PCMCIA 网络适配器并绑定

指定此适配器将绑定到的网卡。默认网卡为“连接的网卡”。OS 或内核无关传输层 (KITL) 可使用 NE2000 进行常规联网。

除非有多个网卡或在使用 Microsoft Loopback Adapter，否则请使用此默认设置。

启用 CS8900 网络适配器并绑定

只有在使用支持 KITL 的映像时，才启用此适配器。由于 Windows Mobile? OS 映像不包含 CS8900 驱动程序，因此不能在一般网络中使用 CS8900 卡。

仅主机网络

创建一个完全包含在主机中的网络。对于一般性工作，不要选择此复选框，以保持与 Visual Studio 的连接。

请参见

概念

设备仿真程序用户界面参考
“仿真程序属性”对话框 ->“常规”
“仿真程序属性”对话框 ->“显示”
“仿真程序属性”对话框 ->“外围设备”


“仿真程序属性”对话框 ->“外围设备”

[image]

设备仿真程序
“仿真程序属性”对话框 ->“外围设备”
请参见

使用此选项卡更改通过串行端口连接的外围设备的设置。

如何显示此选项卡式对话框取决于您的安装。有关更多信息，请参见如何：更改属性设置。

这三个端口均可使用的串行端口选项如下：

  • 不映射。

  • 主机系统上所有可用和已启用的 COM 端口。

如果串行端口设置包含 COM 端口，则相对于其他串行端口设置而言，COM 端口必须唯一。如果选择了没有任何连接的 COM 端口，则仿真程序可能不会启动。

有效映射是主机系统上的所有可用和已启用的 COM 端口。

用户界面元素 | 说明
串行端口 0 | 仿真程序 COM1 端口。
串行端口 1 | 仿真程序调试输出。这是 /c 选项重定向到控制台窗口的输出流。 启用或禁用 KITL 不会更改端口行为。
串行端口 2 | 仿真程序 COM3 端口，用作 IRDA 端口。
为串行端口 1 创建文本控制台窗口 | 打开一个控制台窗口以显示串行端口 1 中所选端口的所有输入和输出内容。OutputDebugString 的输出在此窗口中显示。
Battery | 指示是否显示电池。选中后，设备仿真程序将模拟电池电量。否则，仿真程序将模拟交流电源。
% | 用 0%-100% 之间的百分数表示电池的剩余使用时间。仅当选中“电池”时，才使用此设置。
Speakerphone | 指示是否显示话筒。选中后，设备仿真程序将模拟话筒。
耳机 | 指示是否显示耳机。选中后，设备仿真程序将模拟耳机。
车载 | 指示是否显示车载。选中后，设备仿真程序将模拟车载。

请参见

概念

设备仿真程序用户界面参考
“仿真程序属性”对话框 ->“常规”
“仿真程序属性”对话框 ->“显示”
“仿真程序属性”对话框 ->“网络”
如何：映射串行端口
如何：模拟耳机、话筒或车载的存在


“设备仿真程序管理器”对话框

[image]

设备仿真程序
“设备仿真程序管理器”对话框
请参见

可从 Visual Studio 的“工具”菜单中使用设备仿真程序管理器。

可用的仿真程序

列出在开发计算机上可用的仿真程序。

在树视图中右击某个仿真程序，然后单击“连接”，可以连接到该仿真程序。

刷新

刷新树视图。

请参见

概念

设备仿真程序用户界面参考