Using the Extended Emulator Features

The Emulator features can be extended in many ways. With the Emulator, you can:

Use multi-point touch
Share a directory
Use a camera
Use network features
Use custom skin layout
Use EventCast
Use Emulator start-up options

You can also familiarize yourself with the Emulator directory structure.

Using Multi-point Touch

To create a multi-point touch effect in the Emulator, press and hold the CTRL key (Command key in Mac OS® X), while mouse-clicking on the Emulator screen.

Adding a Touch Point

To add a touch point on the Emulator screen, press and hold the CTRL key (Command key in Mac OS® X) and mouse-click a point on the screen.

You can add touch points up to the maximum amount of multi-point touches. To get the maximum amount, use the System::SystemInfo::GetValue() method with the MultiPointTouchCount key.

Figure: Adding a touch point

Adding a touch point

Moving an Existing Point

To move an existing point one by one, press and hold the CTRL key (Command key in Mac OS® X), mouse-click an existing point, and move it to another location on the screen.

Figure: Moving an existing point

Moving an existing point

To move all existing points together, press and hold the CTRL (Command in Mac OS® X) and SHIFT keys, mouse-click an existing point, and move it to another location on the screen.

Figure: Moving all existing points

Moving all existing points

To move 2 existing points symmetrically together, press and hold the CTRL (Command in Mac OS® X) and ALT keys, mouse-click an existing point, and move it to another location on the screen.

Figure: Symmetrically moving 2 existing points

Symmetrical moving the two existing points

Ending the Multi-point Touch

To end the multi-point touch, release the CTRL key (Command key in Mac OS® X). The touched points on the Emulator screen are invalidated, and the next screen touch event is read as a new event, not part of the previous multi-point touch event.

Figure: Invalidating touched points

Invalidating touched points

Sharing a Directory

You are able to share a directory between Emulator and your computer.

Run the Emulator Manager and click Create New or Modify.
In the File Sharing section of the VM property, enable the Sharing button and select a directory to share.
Start the Emulator.
The host machine's directory is shown as /mnt/host in the Emulator.

You can also add a shared directory in the Emulator Control Panel:

Start the Emulator.
Right-click the Emulator and select Control Panel .
Move to the Host Directory Sharing tab.
Add or remove the host machine directory.

Note
You must have a read/write permission for the directory you want to share.

Using a Camera

With the Emulator, you can develop an application using the Camera API. The Emulator provides a virtual camera. The virtual camera injects frames by using the image files in a host PC or using the Webcam of a PC.

You can use an animated GIF image file. The Emulator provides an image file that can be used as the default.

In addition, you can host a Webcam just like a device camera.

Before running the application, install a USB-connected Webcam or embedded Webcam on your machine. On Linux, the Webcam feature uses libv4l-0. If you do not have it on your machine, this feature does not work properly. You can check the feature status with the following command:

$ dpkg -l | grep libv4l-0

Note
The Webcam must support video4linux2. (Currently, only '/dev/video0' is supported.) Multiple instances of the Emulator can be launched, but only a single Emulator instance can use the camera feature. Depending on the Webcam in use, the Emulator camera feature may not work properly.

The following table lists the host Webcam features.

Table: Webcam features
Feature	Detail	Notes
FPS	30 fps	-
Preview image format	YUYV I420 YV12	-
Capture image format	YUYV I420 YV12 JPEG	-
Preview resolution	QSIF: 160 x 120 QCIF: 176 x 144 QVGA: 320 x 240 CIF: 352 x 288 VGA: 640 x 480	-
Capture resolution	QSIF: 160 x 120 QCIF: 176 x 144 QVGA: 320 x 240 CIF: 352 x 288 VGA: 640 x 480	-
Attributes	Brightness Contrast	Unsupported attributes can return an error. For example, the camera_start_focusing() method returns an error.

Using Network Features

The Tizen Emulator provides 2 types of network backend: NAT-based TCP/IP communication and a bridged network. By default, the NAT-based network is used. You can configure the type of the network backend in Emulator Manager > Network Configuration.

The Emulator is based on the QEMU virtual machine. The NAT type exploits the QEMU user networking (SLIRP) and the bridge type uses tap networking. For more information about networking, see QEMU Networking documentation.

Proxy Configuration

The Tizen Emulator provides 3 methods of proxy configuration. They can be configured in Emulator Manager > Network Configuration:

No proxy: does not use the proxy configuration.
Use host proxy: sets the same proxy value that the host uses.
Use manual proxy: sets manually a proxy value different from the host.

Note
The following preallocated addresses are not supported as a manual proxy: Localhost 127.0.0.1/8 10.0.2.0/24 The automatic proxy configuration is not supported due to license issues.

Note

The following preallocated addresses are not supported as a manual proxy:

Localhost
127.0.0.1/8
10.0.2.0/24

The automatic proxy configuration is not supported due to license issues.

NAT (Network Address Translation)

NAT is the default networking backend and has better usability than other backends. The Emulator supports TCP, UDP, and ping within a guest. However, a raw socket is not supported.

The Emulator virtually provides a LAN (Local Area Network), such as the following:

10.0.2.2: Gateway, host machine
10.0.2.3: DNS (you can specify the Emulator to use the host DNS IP when the Emulator starts)
10.0.2.15: Emulator IP

Figure: Emulator NAT network architecture

Emulator NAT network architecture

Network Connections for NAT

Inbound connections from external to the Emulator fail in the NAT backend. If you want to permit inbound connections and test, you must forward the port by using one of following methods:

ECP (Emulator Control Panel)
You can add port forwarding by using the ECP. In the ECP > Device Manager > Network tab, under User Network Information, click Add port-forwarding and enter the ports to forward.
SDB (Smart Development Bridge)
The SDB provides port forwarding as a command. For more information about the SDB command, see sdb forward.
Xml on boot
You can forward the port on booting the Emulator by modifying the QEMU redirection option. The QEMU redirection option can be appended in the <TIZEN_SDK_DATA>/emulator/vms/<image name>/vm_config.xml file with the following appending command:
```
-redir <PROTOCOL>:<HOST_PORT>:10.0.2.15:<GUEST_PORT>
```
Note that <PROTOCOL> only supports udp and tcp in the <advancedOptions> section:
```
<usability>
   <logging>
      <level>NONE</level>
   </logging>
   <fileSharing/>
   <hwVirtualization>true</hwVirtualization>
   <advancedOptions>-redir tcp:1202:10.0.2.15:22</advancedOptions>
</usability>
```
You can also connect one Emulator instance with another by using redirection. To set up redirection (where A and B are Emulator instances):
1. Set up the server on A, listening to 10.0.2.15:<ServerPort>.
2. On A, append the -redir tcp:<B's localPort>:10.0.2.15:<A's serverPort> redirection option in the vm_config.xml file.
3. On B, let the client connect to 10.0.2.2:<B's localPort>.
For more information, see Connection from Host OS to Guest OS by option -redir.

Bridge (Bridged Network)

The bridge backend requires a dedicated IP for the Emulator and you can communicate to an external without any port forwarding. If you want to use one of the following, you can try the bridge backend:

You want to permit an inbound connection with no port forwarding.
Your application must send and receive broadcast/multicast packets, for example a DLNA (Digital Living Network Alliance) application.
You want to use a firewall-free IP for the Emulator.
You want high performance from the network.

Figure: Emulator bridged network architecture

Emulator bridged network architecture

Note
Network bridging does not work when the underlying physical network device is a wireless device. On Mac OS® X, only physical network device named en0 can be used for bridging.

When the Emulator creates an emulator instance, the Emulator Manager checks the Emulator's IP and sets the properties of the bridged network in Emulator Manager > Network Configuration automatically.

If you have a DHCP (Dynamic Host Configuration Protocol) server on the network, you can configure the Emulator IP using DHCP. If not, enter the IP address that you want to assign.

In the following host operating systems, you must configure the properties of the bridged network directly:

Bridge configuration on Mac OS® X Mavericks and above:
1. In the Apple menu, click System Preferences > Network.
2. In the Action menu, click Manage Virtual Interfaces.
3. Click Add (+) > New Bridge, and select the Ethernet interfaces to include in the bridge.
4. Configure the TCP/IP for bridge, such as IP and DNS.
Bridge configuration on Windows 8 and above:
1. Click the Windows Start () > Control Panel. In the search box, enter "adapter", and click Network and Sharing Center > View network connections.
2. Right-click the physical network connection used for bridging, and click Properties.
3. On the General tab (for a local area connection), click Internet Protocol (TCP/IP) > Properties.
4. Click Obtain an IP address automatically to delete IP configuration, and click OK. The IP configuration (IP address, Subnet mask, and Default gateway) are used for the configuration of the bridged network.
5. While holding down the Ctrl key, select the network connection and the tap device that you want to include in the bridge. For example, tap1 and Local area connection.
6. Right-click one of the selected network connections, and click Bridge Connections.
7. Configure TCP/IP of the Network bridge. Reuse the deleted TCP/IP configuration of step 4.

Using Custom Skin Layout

An Emulator skin comprises an XML meta file, which defines layout-related information, such as skin image file name, display location, and the location of hardware keys. This file is located in <TIZEN_SDK>/platform/<PROFILE_NAME>/emulator-resources/skins/<SKIN_NAME>/layout.xml.

The following example shows the contents of the layout.xml layout file:

<?xml version="1.0" encoding="UTF-8"?>
<EmulatorUI xmlns="http://www.tizen.org/emulator/ui/layout">
   <layoutVersion>2.4</layoutVersion>
   <formList>
      <!--Skin mode definition-->
      <form name="Portrait">
         <display>
            <!--Display screen size and position-->
            <region left="30" top="81" width="480" height="800"/>
            <!--Rotate display screen by degree-->
            <angle>0</angle>
         </display>
         <!--Resource file name of the usual skin image-->
         <normalImage>default_0.png</normalImage>
         <!--Resource file name of the skin image when hardware key events occur-->
         <pressedImage>default_0_p.png</pressedImage>
         <keyList>
            <key name="Home"> <!--Optional-->
               <!--Hardware key region size and position-->
               <region left="233" top="882" width="74" height="74"/>
               <keycode>139</keycode> <!--Keycode value-->
               <!--This line to be displayed when mouse hovers over the hardware key region-->
               <tooltip>Home</tooltip>
               <!--Defined keyboard short cut-->
               <shortcut>F1</shortcut>
            </key>
         </keyList>
         <hover>
            <!--RGB line color of the hardware key hover-->
            <color R="255" G="255" B="255"/>
         </hover>
      </form>
   </formList>
</EmulatorUI>

The Emulator skin also comprises a property file, which defines skin-related information, such as skin name and supported resolutions. This file is located in <TIZEN_SDK>/tools/emulator/skins/<SKIN_NAME>/info.ini.

The following example shows the contents of the info.ini property file:

skin.name=Phone 480x800
resolution.width=480
resolution.height=800

To create your own skin layout:

Create a new skin folder in the <TIZEN_SDK>/tools/emulator/skins/ folder.
In the skin folder, define the contents of the layout.xml and info.ini files and include the required skin image files.
Select the skin name in the Emulator Manager. You can also use the Emulator start-up options in the command line.

The image defined in your modified XML meta file is displayed when the Emulator is launched.

Note
If you re-install the Tizen IDE, the custom skin folders are reset.

Using EventCast

The Emulator supports event injection using ECP (Emulator Control Panel). However, injecting sensor events using ECP is less intuitive and convenient. When you are injecting events, touching the Emulator screen simultaneously is impossible. EventCast enables you to inject sensor and touch events more intuitively using a real target device.

The following figure illustrated how the EventCast application in the target device gathers events and passes them to the Emulator controller, which converts and hands them over to the Tizen platform. This is convenient in case you do not have a Tizen mobile device.

Figure: EventCast architecture

eventcast_architecture

EventCast provides the following features:

Touch: Maximum number of touch points is 10
Sensors: Accelerometer, gyroscope, geo-magnetic, proximity, light sensors
Display: Getting images of the Tizen Emulator and drawing them when using touch features

Prerequisites

When connecting through USB, ADB is required to make a connection. If you have already installed Android SDK on the PC, ADB is located at a <installed Android SDK>/sdk/platform-tools directory. Otherwise, you can download only ADB or install Android SDK.

To install ADB:

Ubuntu/Mac OS® X: Download ADB and then install it in the /usr/bin directory.

For more information, see http://code.google.com/p/adb-fastboot-install/.
Download ADB and install it in the C:\ADB directory.

For more information, see http://rubenalamina.mx/custom-installers/android-adb-fastboot/.

When connecting through Wi-Fi, make sure that your android device and PC are within the same AP.

Installing EventCaster

EventCaster is the application on the target device. It communicates with the Tizen Emulator through the TCP/IP protocol. It can connect to the Emulator using USB or Wi-Fi.

You can install the EventCaster from Google Play(https://github.com/eventcaster/eventcaster.git) and install it manually.

Connecting EventCaster to the Emulator

To connect the EventCaster application to the Emulator:

Connect through USB:

Locate the developer options

On most devices running Android 3.2 or older, you can find the option under Settings > Applications > Development.

On Android 4.0 and newer, it is in Settings > Developer options.

Note
On Android 4.2 and newer, the developer options are hidden by default. To make them available, go to Settings > About phone and tap Build number seven times. Return to the previous screen to find the developer options.

Enable USB debugging.
Connect the device to a computer through USB.
Launch the EventCaster.
Start the server using default port (7000) or enter the port number.
Forward a TCP port using the adb forward command.
For example, you can forward the 7000 port in the application to the 1234 port in your computer: adb forward tcp:1234 tcp:7000
Launch the Tizen Emulator and the Emulator Control Panel (ECP) in the Emulator context menu.
Select the USB checkbox on the EventCast tab of the Emulator Control Panel.
Enter the forwarded port number and click Connection on the ECP.
If the Emulator connects to app successfully, the Show Event button in the application is activated.
Click Show Event. You can now inject a sensor or touch value to the Emulator.

Connect through Wi-Fi:
1. Enable Wi-Fi on device and select the Wi-Fi network.
2. Connect the Android device to a network where you also have a computer running the Emulator.
3. Launch EventCaster and click Read WiFi.
  The application gets the IP address of the connected network.
4. Choose Start Server button.
5. Select the Wi-Fi checkbox on the EventCast tab of the Emulator Control Panel.
6. Enter the IP address and port number using EventCaster and then click Connect on the Emulator Control Panel.
  If the Emulator connects to the application successfully, the Show Event button in the application is activated.
7. Click Show Event. You can now inject a sensor or touch value to the Emulator.

Using Emulator Start-up Options

You can launch the Emulator with specific settings by defining start-up options in the command line:

# ./emulator-x86 --skin-args <skin options> --qemu-args <QEMU options>

The Emulator binaries are located in the <TIZEN_SDK>/tools/emulator/bin directory. The Tizen Emulator provides 2 types of start-up options that you can set: skin options (such as width and height) and QEMU options (such as network and memory).

The following tables list the available options.

Table: Emulator skin options
Category	Option	Mandatory	Description
Resolution	width=x	Yes	This option makes the Emulator use a specific skin image width. The width value must be one of the video resolutions that the Emulator can support.
Resolution	height=x	Yes	This option makes the Emulator use a specific skin image height. The height value must be one of the video resolutions that the Emulator can support.
Heartbeat	hb.ignore=x	No	This option is used to activate the Emulator debugging mode. Generally, a skin process for the Emulator periodically checks the heartbeat that an Emulator process sends. When the Emulator is in the debugging mode using gdb, the skin process is terminated automatically, because the Emulator cannot send a heartbeat to the skin process. In that case, you can set the hb.ignore option as true to debug the Emulator. If this option is true, the skin process does not check the heartbeat that the Emulator sends. The default value of this option is false.
Skin image file path	skin.path=xxx	Yes	Emulator loads the skin image files in this path. If this option is omitted, the Emulator finds the image files in the installed 'skins' directory.

Table: Emulator QEMU options
Category	Option	Description
File system image	-drive file=<IMAGE_PATH>/emulimg.x86	Sets an image path to the file to be used as a drive image.
Swap file system image	-drive file=<SWAP_IMAGE_PATH>/swap.img	Sets a swap image path to the file to be used as a swap image.
Network	-net user	Uses the user mode network stack, which requires no administrator privilege to run.
Network	-net nic,model=virtio,macaddr=<MAC_ADDRESS>	Creates a new network interface card and connects it to VIRTIO. <MAC_ADDRESS> is recorded in <TIZEN_SDK_DATA>/emulator/vms/.tizen-em-info. For example: E8:11:32:33:38:81
USB	-usb	Enables the USB driver.
TouchScreen	-device virtio-touchscreen-pci	Uses the Maru Touchscreen device for display.
Kernel	-kernel <KERNEL_PATH>	Uses bzImage as the kernel image.
BIOS	-vga none	Sets the VGA card.
BIOS	-L <BIOS_PATH>	Sets the directory for the BIOS, VGA BIOS, and key maps.
Time	-rtc base=utc	Sets the real time clock with UTC.
KVM (in Ubuntu®)	-enable-kvm	Enables KVM (hardware virtualization support).
HAX (in Windows® or Mac OS® X)	-enable-hax	Enables HAX (hardware virtualization support).
SMP	-smp <NUMBER OF CPUs>	Sets the number of CPUs.
Boot order	-boot c	Sets the boot order of the Emulator. The letter c indicates a hard disk.
Kernel parameters	-append<parameters>	Sets the kernel command line parameters from the Emulator to the kernel.
Kernel log	-serial file:<LOG_PATH>/emulator.klog	Writes the kernel log into the <LOG_PATH>/emulator.klog file.
Memory	-m <MEMORY_SIZE>	Sets the memory size in the Tizen platform to, for example, 512 or 1024.
Board	-M maru-x86-machine	Sets the Emulator machine as maru-x86-machine.
Video card	-enable-vigs	Enables VIGS (Virtualized Graphics System) as the video card.
Video card	-vigs-backend <VIGS_BACKEND>	Sets the back end as sw or gl (software or OpenGL®).
GPU support	-enable-yagl	Enables host GL acceleration.
GPU support	-yagl-backend <YAGL_BACKEND>	Sets the back end as vigs or offscreen.
Sound	-soundhw all	Enables all sound cards.
Display booting status	-device virtio-esm-pci	Sets the display booting status of the Emulator.
Codec	-device codec-pci	Enables codec devices.
Hardware key	-device virtio-hwkey-pci	Enables hardware keys.
Host keyboard	-device virtio-keyboard-pci	Enables host keyboards.
Rotary	-device virtio-rotary-pci	Enables a rotary device.
Brightness	-device maru-brightness	Enables the brightness control.
Camera	-device maru-camera	Enables the host Webcam support.
Power	-device virtio-power-pci	Enables the battery.
Jack	-device virtio-jack-pci,jacks=<Jack types>	Enables jack devices. Supported jacks are USB, earjack, ear key, HDMI, and charger. The ampersand ('&') symbol is used for multiple jacks.
Emulator virtual device interface	-device virtio-evdi-pci	Enables the common interface between the Emulator daemon on the guest side and the Emulator on the host side. To use the Emulator Control Panel, this option is required.
Sensors	-device virtio-sensor-pci,sensors=<Sensor types>	Enables sensor devices. Supported sensors are accelerometer, gyroscope, geomagnetic, light, proximity, haptic, pressure, ultraviolet, and heart rate monitor. The names of sensor types are accel, gyro, geo, light, proxy, haptic, press, uv, and hrm, respectively. The ampersand ('&') symbol is used for multiple sensor support.
Vmodem	-device virtio-vmodem-pci	Enables the Virtual Modem.

The following command is an example of using the Emulator start-up options:

Mobile

<TIZEN_SDK>/tools/emulator/bin/emulator-x86.exe --skin-args width=480 height=800 skin.path=
<TIZEN_SDK>/platforms/<PROFILE_NAME>/emulator-resources/skins/<SKIN_NAME> --qemu-args -drive file=
<TIZEN_SDK_DATA>/emulator/vms/<VM_NAME>/emulimg-<VM_NAME>.x86,if=virtio,index=1 -boot c -append "console=ttyS0 video=LVDS-1:480x800-32@60 dpi=2330 ip=10.0.2.15::10.0.2.2:255.255.255.0::eth0:none vm_name=<VM_NAME>" -serial file:
<TIZEN_SDK_ DATA >/emulator/vms/<VM_NAME>/logs/emulator.klog -m 512 -M maru-x86-machine -net nic,model=virtio,macaddr=<MAC_ADDRESS> -soundhw all -usb -vga none -enable-vigs -L 
<TIZEN_SDK>/tools/emulator/data/bios -kernel 
<TIZEN_SDK>/tools/emulator/data/kernel/bzImage.x86 -net user -rtc base=utc -drive file=
<TIZEN_SDK_DATA>/emulator/vms/<VM_NAME>/swap-<VM_NAME>.img,if=virtio,
index=2 -enable-hax -vigs-backend gl -enable-yagl -yagl-backend vigs -device virtio-esm-pci -device virtio-hwkey-pci -device 
virtio-keyboard-pci -device virtio-evdi-pci -device virtio-sensor-pci,sensors=accel&geo&gyro&light&proxi&
haptic&press&uv&hrm -device virtio-power-pci -device 
virtio-jack-pci,jacks=earjack&charger&usb -device codec-pci -device 
maru-brightness -device virtio-vmodem-pci -device maru-camera -device virtio-touchscreen-pci,max_point=10

Wearable

<TIZEN_SDK>/tools/emulator/bin/emulator-x86.exe --skin-args width=360 height=360 skin.path=
<TIZEN_SDK>/platforms/<PROFILE_NAME>/emulator-resources/skins/<SKIN_NAME> --qemu-args -drive file=
<TIZEN_SDK_DATA>/emulator/vms/
<VM_NAME>/emulimg-<VM_NAME>.x86,if=virtio,index=1 -boot c -append &quot;console=ttyS0 video=LVDS-1:360x360-32@60 dpi=302 vm_name=<VM_NAME>&quot; -serial file:
<TIZEN_SDK_DATA>/emulator/vms/<VM_NAME>/logs/emulator.klog -m 512 -M maru-x86-machine -net nic,model=virtio,macaddr=<MAC_ADDRESS> -soundhw all -usb -vga none -enable-vigs -L 
<TIZEN_SDK>/tools/emulator/data/bios -kernel <TIZEN_SDK>/tools/emulator/data/kernel/bzImage.x86 -net user -rtc base=utc -drive file=
<TIZEN_SDK_DATA>/emulator/vms/<VM_NAME>/swap-<VM_NAME>.img,if=virtio,index=2 -enable-hax -vigs-backend gl -enable-yagl -yagl-backend vigs -device 
virtio-esm-pci -device virtio-hwkey-pci -device virtio-evdi-pci -device virtio-sensor-pci,
sensors=accel&geo&gyro&light&proxi&haptic&press&uv&hrm -device 
virtio-power-pci -device virtio-jack-pci,jacks=charger&usb -device codec-pci -device 
maru-brightness -device virtio-vmodem-pci -device maru-camera -device virtio-touchscreen-pci,max_point=2 -device virtio-rotary-pci

Emulator Directory Structure

The following table describes the content of the Emulator directory, located in the <TIZEN_SDK>/tools/emulator folder.

Table: Emulator directory content
Folder or file	Description
bin/	Binary files
bin/emulator-control-panel.jar	Emulator Control Panel
bin/emulator-control-panel-cli.jar	Emulator Control Panel CLI (Command Line Interface)
bin/emulator-manager	Emulator manager binary to launch the emulator-manager.jar file
bin/emulator-manager.jar	Emulator manager jar, which can also launch the Emulator with the Emulator Manager.
bin/em-cli	Emulator manager CLI (Command Line Interface)
bin/emulator-skin.jar	Emulator skin
bin/emulator-x86	x86 Emulator binary, including QEMU
bin/protobuf.jar	Protocol buffer library
bin/libecp.jar	profile independent library for ECP
bin/swt.jar	SWT library
bin/jna-<version>.jar	JNA library
data/bios/	.bin files for initializing the guest OS
data/kernel/	Kernel image for the guest Linux OS
storages/sdcard/sdcard_xxx.img	.img files (base sdcard images) specific to the data size used by the Emulator Manager
storages/swap/swap.img	Disk image for swap

The following table describes the platform directories that are located in the <TIZEN_SDK>/platform/<Profile>-<VERSION>/emulator-images folder.

Table: Platform image directory content
Name	Description
x86-standard/	Platform directory
x86-standard/emuling-<VERSION>.x86	Base image, which represents an Emulator root file system for x86 in the guest OS view
x86-standard/info.ini	File for specifying information of the Emulator disk image

The following table describes the platform directories that are located in the <TIZEN_SDK>/platforms/<Profile>-<VERSION>/emulator-resources folder.

Table: Platform directory resource content
Name	Description
plugins/	Plugins for profile
plugins/ecp-plugin.jar	Plugin for the Emulator Control Panel
plugins/ecp-plugin.xml	XML file for the ecp-plugin.jar file configuration
plugins/em-plugin.jar	Plugin for the Emulator Manager
skins/	Emulator skin images specific to the Emulator resolution, and icons for the Emulator option button and shortcut
skins/<skin name>/info.ini	File for specifying Emulator skin information
skins/<skin name>/layout.xml	Metafile for the Emulator skin layout
template/<image name>.xml	XML file for default configuration of the virtual machine created by the Emulator Manage
template/<image name>-template.xml	XML file for the template of the virtual machine created by the Emulator Manager

The following table describes the directory structure of the user-specific files that are located in the <TIZEN_SDK_DATA>/emulator/vms folder.

Table: User directory content
Name	Description
emulator-manager.log	Emulator Manager log file
last-created_<PROFILE>-<VERSION>_<image name>.xml	This file saves properties of VM that user created last. And when user create new VM next time, properties in this file is displayed as default
.em.lock	This lock file is used for synchronization between VM operation like modify, delete, launch
.tizen-em-info	Configuration file for Emulator Manager
<image name>/	Target-specific images
<image name>/.skin.properties	Hidden data for the Emulator skin
<image name>/emulimg-<image name>.x86	Writable <image name> image file
<image name>/swap-<image name>.img	Swap image file
<image name>/vm_config.xml	Hardware configuration (for more information, see Virtual Machine)
<image name>/${USER}.lock	This lock file is used for synchronization between VM and Emulator Control Panel to set/get operations
<image name>/logs/	Log files (Emulator, kernel, emulator-skin log)