diff options
Diffstat (limited to 'src/plugins/emulator/src/com/motorola/studio/android/emulator/device/instance/AndroidDeviceInstance.java')
| -rw-r--r-- | src/plugins/emulator/src/com/motorola/studio/android/emulator/device/instance/AndroidDeviceInstance.java | 776 |
1 files changed, 776 insertions, 0 deletions
diff --git a/src/plugins/emulator/src/com/motorola/studio/android/emulator/device/instance/AndroidDeviceInstance.java b/src/plugins/emulator/src/com/motorola/studio/android/emulator/device/instance/AndroidDeviceInstance.java new file mode 100644 index 0000000..b08f556 --- /dev/null +++ b/src/plugins/emulator/src/com/motorola/studio/android/emulator/device/instance/AndroidDeviceInstance.java @@ -0,0 +1,776 @@ +/*
+* Copyright (C) 2012 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+package com.motorola.studio.android.emulator.device.instance;
+
+import static com.motorola.studio.android.common.log.StudioLogger.error;
+import static com.motorola.studio.android.common.log.StudioLogger.info;
+import static com.motorola.studio.android.common.log.StudioLogger.warn;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+
+import org.eclipse.core.runtime.IAdaptable;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.NullProgressMonitor;
+import org.eclipse.core.runtime.Status;
+import org.eclipse.core.runtime.jobs.Job;
+import org.eclipse.jface.resource.ImageDescriptor;
+import org.eclipse.sequoyah.device.framework.model.AbstractMobileInstance;
+import org.eclipse.sequoyah.device.framework.model.handler.ServiceHandler;
+import org.eclipse.sequoyah.vnc.protocol.PluginProtocolActionDelegate;
+import org.eclipse.sequoyah.vnc.protocol.lib.ProtocolHandle;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.ui.model.IWorkbenchAdapter;
+
+import com.android.sdklib.IAndroidTarget;
+import com.android.sdklib.internal.avd.AvdInfo;
+import com.motorola.studio.android.adt.DDMSFacade;
+import com.motorola.studio.android.adt.ISerialNumbered;
+import com.motorola.studio.android.adt.SdkUtils;
+import com.motorola.studio.android.emulator.EmulatorPlugin;
+import com.motorola.studio.android.emulator.core.exception.InstanceStopException;
+import com.motorola.studio.android.emulator.core.model.IAndroidEmulatorInstance;
+import com.motorola.studio.android.emulator.core.model.IInputLogic;
+import com.motorola.studio.android.emulator.device.IDevicePropertiesConstants;
+import com.motorola.studio.android.emulator.device.definition.AndroidEmuDefMgr;
+import com.motorola.studio.android.emulator.device.instance.options.StartupOptionsMgt;
+import com.motorola.studio.android.emulator.i18n.EmulatorNLS;
+import com.motorola.studio.android.emulator.logic.AbstractStartAndroidEmulatorLogic;
+import com.motorola.studio.android.emulator.logic.AndroidLogicUtils;
+import com.motorola.studio.android.emulator.logic.IAndroidLogicInstance;
+import com.motorola.studio.android.emulator.logic.stop.AndroidEmulatorStopper;
+import com.motorola.studio.android.nativeos.NativeUIUtils;
+
+/**
+ * DESCRIPTION:
+ * This class represents a Android Emulator instance
+ *
+ * RESPONSIBILITY:
+ * - Hold all attributes of an Android Emulator instance
+ * - Provide methods for testing if started and to stop the instance
+ *
+ * COLABORATORS:
+ * None.
+ *
+ * USAGE:
+ * This class is not meant to be used directly by the user. All commands to the
+ * Android Emulator instance shall be provided through the device framework.
+ */
+public class AndroidDeviceInstance extends AbstractMobileInstance implements IAndroidLogicInstance,
+ IWorkbenchAdapter, ISerialNumbered
+{
+ /**
+ * The protocol that is executed by this instance
+ */
+ private ProtocolHandle handle;
+
+ /**
+ * True if this instance has and supports CLI display; false otherwise
+ */
+ private boolean hasCli = false;
+
+ /**
+ * Current layout of this instance
+ */
+ private String currentLayout;
+
+ private Process process;
+
+ private long windowHandle;
+
+ private Composite composite;
+
+ /**
+ * Tests if this instance is in started or stopped state
+ *
+ * @return true if started, false if stopped
+ */
+ public boolean isStarted()
+ {
+ boolean instanceStarted = false;
+ String status = getStatus();
+ if (EmulatorPlugin.STATUS_ONLINE_ID.equals(status))
+ {
+ instanceStarted = true;
+ }
+
+ return instanceStarted;
+ }
+
+ public boolean isConnected()
+ {
+ if (super.getProperties()
+ .getProperty(IDevicePropertiesConstants.useVnc, NativeUIUtils.getDefaultUseVnc())
+ .equals("true"))
+ {
+ ProtocolHandle protocolHandle = getProtocolHandle();
+ if (protocolHandle != null)
+ {
+ return PluginProtocolActionDelegate.isProtocolRunning(protocolHandle);
+ }
+ return false;
+ }
+ else
+ {
+ return isStarted();
+ }
+
+ }
+
+ /**
+ * Method used by the emulator core to stop the instance on errors
+ *
+ * @see IAndroidEmulatorInstance#stop(boolean)
+ *
+ * @param force True if no interaction with the user is desired to
+ * perform the stop operation; false otherwise
+ */
+ public void stop(boolean force) throws InstanceStopException
+ {
+
+ info("Stopping the Android Emulator instance: " + this);
+
+ // FIRST SCENARIO: THE INSTANCE IS STARTED AND FAILED DURING OPERATION
+ // If the instance is in started state, the stop handler is called to delegate the state
+ // maintenance to TmL, which is correct.
+ if (isStarted())
+ {
+ if (getStateMachineHandler().isTransitioning())
+ {
+ // Free other threads to continue their jobs if one is already running the procedure
+ info("The instance is already executing a stop process: " + this);
+ throw new InstanceStopException("The instance is already executing a stop process");
+ }
+ else
+ {
+ info("Instance is started. Run the regular transition to stopped status: " + this);
+ ServiceHandler stopHandler = EmulatorPlugin.getStopServiceHandler();
+ if (stopHandler != null)
+ {
+ try
+ {
+ Map<Object, Object> args = new HashMap<Object, Object>();
+ args.put(EmulatorPlugin.FORCE_ATTR, true);
+ stopHandler.run(this, args);
+ }
+ catch (Exception e)
+ {
+ // Should not enter here, because the state has been tested before
+ error("The instance is not in an appropriate state for stopping");
+ }
+ info("Finished stop process: " + this);
+ }
+ }
+ }
+ // SECOND SCENARIO: THE INSTANCE WAS STARTING AND FAILED DURING THE PROCESS
+ // If the instance is not in started state, TmL will not allow the stop service to run. In
+ // this case, the methods must be called manually, and the state does not need maintenance
+ // (it has never been updated, as updating happens in the end of a transition)
+ else
+ {
+ if (getStateMachineHandler().isTransitioning())
+ {
+
+ info("Instance is not fully started yet. Execute a stop process directly..." + this);
+ final Job haltJob = new Job(EmulatorNLS.UI_AndroidDeviceInstance_StopInstanceJob)
+ {
+ @Override
+ protected IStatus run(IProgressMonitor monitor)
+ {
+ AndroidEmulatorStopper.stopInstance(AndroidDeviceInstance.this, true, true,
+ monitor);
+
+ if (getStatus().equals(EmulatorPlugin.STATUS_OFFLINE_NO_DATA))
+ {
+ info("Instance was initially in stopped/clean status. Rollback if needed."
+ + this);
+
+ File userdataFile = getUserdata();
+ if ((userdataFile != null) && userdataFile.exists())
+ {
+ info("Deleted data created during the start tentative."
+ + userdataFile);
+ userdataFile.delete();
+ }
+ }
+
+ info("Finished stop process: " + AndroidDeviceInstance.this);
+ return Status.OK_STATUS;
+ }
+ };
+ haltJob.schedule();
+ }
+ }
+ }
+
+ /**
+ *
+ */
+ @Override
+ public Properties getProperties()
+ {
+ Properties properties = super.getProperties();
+
+ // synchronize instance properties data with current sdk...
+ File fromSdk = SdkUtils.getUserdataDir(getName());
+ if (fromSdk != null)
+ {
+ properties.put(IDevicePropertiesConstants.vmPath, fromSdk.getAbsolutePath());
+ }
+
+ return properties;
+ }
+
+ /**
+ * @see IAndroidEmulatorInstance#getHasCli()
+ */
+ public boolean getHasCli()
+ {
+ return hasCli;
+ }
+
+ /**
+ * @see IAndroidEmulatorInstance#getInstanceIdentifier()
+ */
+ public String getInstanceIdentifier()
+ {
+ return getSerialNumber();
+ }
+
+ /**
+ * @see IAndroidEmulatorInstance#getProtocolHandle()
+ */
+ public ProtocolHandle getProtocolHandle()
+ {
+ return handle;
+ }
+
+ /**
+ * @see IAndroidEmulatorInstance#getEmulatorDefId()
+ */
+ public String getEmulatorDefId()
+ {
+ return getProperties().getProperty(IDevicePropertiesConstants.emulatorDefId);
+ }
+
+ /*
+ * (non-Javadoc)
+ * @see com.motorola.studio.android.emulator.core.model.IAndroidEmulatorInstance#getCurrentLayout()
+ */
+ public String getCurrentLayout()
+ {
+ return currentLayout;
+ }
+
+ /*
+ * (non-Javadoc)
+ * @see com.motorola.studio.android.emulator.core.model.IAndroidEmulatorInstance#setCurrentLayout(java.lang.String)
+ */
+ public void setCurrentLayout(String layoutName)
+ {
+ currentLayout = layoutName;
+ }
+
+ /**
+ * @see IAndroidEmulatorInstance#setHasCli(boolean)
+ */
+ public void setHasCli(boolean hasCli)
+ {
+ this.hasCli = hasCli;
+ }
+
+ /**
+ * @see IAndroidEmulatorInstance#setProtocolHandle(ProtocolHandle)
+ */
+ public void setProtocolHandle(ProtocolHandle handle)
+ {
+ this.handle = handle;
+ }
+
+ /**
+ * Resets all the previous runtime state to clean them for next execution
+ */
+ void resetRuntimeVariables()
+ {
+ handle = null;
+ hasCli = false;
+ currentLayout = null;
+ }
+
+ /**
+ * This version of getAdapter needs to assure that only an Android
+ * Device instance is compatible with itself
+ *
+ * @see IAdaptable#getAdapter(Class)
+ */
+ @SuppressWarnings("rawtypes")
+ @Override
+ public Object getAdapter(Class adapter)
+ {
+ if (adapter.isInstance(this))
+ {
+ return this;
+ }
+ else
+ {
+ return null;
+ }
+ }
+
+ /**
+ * Retrieves the default properties to be used upon instance creation
+ *
+ * @param defaultProperties property object to be filled
+ * @param vmSkin Android VM skin
+ */
+ public static void populateWithDefaultProperties(Properties defaultProperties)
+ {
+
+ AndroidEmuDefMgr emuDefMgr = AndroidEmuDefMgr.getInstance();
+
+ // When removing the emulator definition extension, remove this hardcoded set as
+ // well as the constant declaration from the Activator. If the Mot skin plugin is used,
+ // find another way to set this variable
+ String emuDefId = EmulatorPlugin.DEFAULT_EMULATOR_DEFINITION;
+
+ // Emulator Definition
+ defaultProperties.setProperty(IDevicePropertiesConstants.emulatorDefId, emuDefId);
+
+ // skin from Emulator Definition
+ defaultProperties.setProperty(IDevicePropertiesConstants.skinId,
+ emuDefMgr.getSkinId(emuDefId));
+
+ // command line arguments from Emulator Definition
+ defaultProperties.setProperty(IDevicePropertiesConstants.commandline,
+ emuDefMgr.getCommandLineArgumentsForEmuDefinition(emuDefId));
+
+ // default timeout
+ defaultProperties.setProperty(IDevicePropertiesConstants.timeout,
+ IDevicePropertiesConstants.defaultTimeoutValue);
+
+ //default useVnc
+ defaultProperties.setProperty(IDevicePropertiesConstants.useVnc,
+ NativeUIUtils.getDefaultUseVnc());
+
+ //default useProxy
+ defaultProperties.setProperty(IDevicePropertiesConstants.useProxy,
+ IDevicePropertiesConstants.defaultUseProxyValue);
+ }
+
+ /**
+ * Populate VM Target and VM skin
+ *
+ * @param instanceName
+ * @param instanceProperties
+ */
+ public static void populateWithVMInfo(String instanceName, Properties instanceProperties)
+ {
+ AvdInfo vmInfo = SdkUtils.getValidVm(instanceName);
+
+ if (vmInfo != null)
+ {
+ // VM target
+ instanceProperties.setProperty(IDevicePropertiesConstants.vmTarget, vmInfo.getTarget()
+ .getName());
+
+ // ABI Type
+ instanceProperties.setProperty(IDevicePropertiesConstants.abiType, vmInfo.getAbiType());
+
+ // VM skin
+ instanceProperties.setProperty(IDevicePropertiesConstants.vmSkin,
+ SdkUtils.getSkin(vmInfo));
+
+ // VM path
+ instanceProperties.setProperty(IDevicePropertiesConstants.vmPath,
+ vmInfo.getDataFolderPath());
+ String useSnapShot = vmInfo.getProperties().get("snapshot.present");
+ if (useSnapShot == null)
+ {
+ useSnapShot = "false";
+ }
+
+ instanceProperties.setProperty(IDevicePropertiesConstants.useSnapshots, useSnapShot);
+ if (instanceProperties.getProperty(IDevicePropertiesConstants.startFromSnapshot) == null)
+ {
+ instanceProperties.setProperty(IDevicePropertiesConstants.startFromSnapshot,
+ useSnapShot);
+ }
+ if (instanceProperties.getProperty(IDevicePropertiesConstants.saveSnapshot) == null)
+ {
+ instanceProperties
+ .setProperty(IDevicePropertiesConstants.saveSnapshot, useSnapShot);
+ }
+ }
+ }
+
+ public String getSkinId()
+ {
+ return getProperties().getProperty(IDevicePropertiesConstants.skinId);
+ }
+
+ @SuppressWarnings("restriction")
+ public File getSkinPath()
+ {
+ File skinFile = null;
+
+ AvdInfo avdInfo = SdkUtils.getValidVm(getName());
+ if (avdInfo != null)
+ {
+ String skinPath = avdInfo.getProperties().get("skin.path");
+ skinPath = SdkUtils.getCurrentSdk().getSdkLocation() + skinPath;
+ IAndroidTarget target = avdInfo.getTarget();
+ File candidateFile = new File(skinPath);
+ //If path specified on the skin does not exist, try to retrieve it from the target.
+ if (!candidateFile.exists())
+ {
+ candidateFile =
+ SdkUtils.getCurrentSdk().getAvdManager()
+ .getSkinPath(SdkUtils.getSkin(avdInfo), target);
+ }
+ if (!target.isPlatform())
+ {
+ if (!candidateFile.isDirectory())
+ {
+ IAndroidTarget baseTarget = target.getParent();
+ skinPath = getSkinFolderPath(baseTarget);
+ skinFile = new File(skinPath);
+ }
+ else
+ {
+ skinFile = candidateFile;
+ }
+ }
+ else
+ {
+ skinFile = candidateFile;
+ }
+ }
+ return skinFile;
+ }
+
+ private String getSkinFolderPath(IAndroidTarget target)
+ {
+ String vmSkin = getProperties().getProperty(IDevicePropertiesConstants.vmSkin);
+ return target.getLocation() + File.separator + "skins" + File.separator + vmSkin;
+ }
+
+ /**
+ * Get the timeout in milliseconds
+ *
+ * @see com.motorola.studio.android.emulator.logic.IAndroidLogicInstance#getTimeout()
+ */
+ public int getTimeout()
+ {
+ int timeout = 0;
+ String timeoutString = null;
+ try
+ {
+ info("Try to get Timeout property from " + this);
+ Properties instanceProps = getProperties();
+ timeoutString = instanceProps.getProperty(IDevicePropertiesConstants.timeout);
+ timeout = Integer.parseInt(timeoutString) * 1000; //convert to milis
+ }
+ catch (Exception e)
+ {
+ warn("Unnable to parse timeout string:" + timeoutString);
+ timeout = Integer.parseInt(IDevicePropertiesConstants.defaultTimeoutValue) * 1000;
+ }
+
+ return timeout;
+ }
+
+ public IAndroidTarget getAndroidTarget()
+ {
+ IAndroidTarget result = null;
+ AvdInfo avdInfo = SdkUtils.getValidVm(getName());
+ if (avdInfo != null)
+ {
+ result = avdInfo.getTarget();
+ }
+ return result;
+ }
+
+ public String getTarget()
+ {
+ String result = null;
+ IAndroidTarget target = getAndroidTarget();
+ if (target != null)
+ {
+ result = target.getName();
+ }
+ return result;
+ }
+
+ public int getAPILevel()
+ {
+ int result = -1;
+ IAndroidTarget target = getAndroidTarget();
+ if (target != null)
+ {
+ result = target.getVersion().getApiLevel();
+ }
+ return result;
+ }
+
+ public String getCommandLineArguments()
+ {
+ return getProperties().getProperty(IDevicePropertiesConstants.commandline,
+ NativeUIUtils.getDefaultCommandLine());
+ }
+
+ public AbstractStartAndroidEmulatorLogic getStartLogic()
+ {
+ String emuDefinition = getEmulatorDefId();
+ AndroidEmuDefMgr definitionManager = AndroidEmuDefMgr.getInstance();
+ return definitionManager.getStartLogic(emuDefinition);
+ }
+
+ public IInputLogic getInputLogic()
+ {
+ String emuDefinition = getEmulatorDefId();
+ AndroidEmuDefMgr definitionManager = AndroidEmuDefMgr.getInstance();
+ return definitionManager.getInputLogic(emuDefinition, this);
+ }
+
+ public boolean hasDevice()
+ {
+ return (DDMSFacade.getDeviceBySerialNumber(getSerialNumber()) != null);
+ }
+
+ public void changeOrientation(final String parameters)
+ {
+
+ new Thread(new Runnable()
+ {
+
+ public void run()
+ {
+ try
+ {
+ DDMSFacade.execRemoteApp(getSerialNumber(),
+ AndroidLogicUtils.ORIENTATION_BASE_COMMAND + parameters,
+ new NullProgressMonitor());
+ }
+ catch (IOException e)
+ {
+ error("Failed to send the command to change the emulator display orientation to portrait.");
+ }
+
+ }
+ }).start();
+
+ }
+
+ /* (non-Javadoc)
+ * @see com.motorola.studio.android.emulator.logic.IAndroidLogicInstance#getUserdata()
+ */
+ public File getUserdata()
+ {
+ return SdkUtils.getUserdataFile(getName());
+ }
+
+ /* (non-Javadoc)
+ * @see com.motorola.studio.android.emulator.logic.IAndroidLogicInstance#getSnapshotOriginalFilePath()
+ */
+ public File getSnapshotOriginalFilePath()
+ {
+ String snapshotFilePath;
+ File snapshotOriginalFile = null;
+ snapshotFilePath =
+ SdkUtils.getSdkToolsPath() + "lib" + File.separator + "emulator" + File.separator
+ + "snapshots.img";
+ snapshotOriginalFile = new File(snapshotFilePath);
+ if (!snapshotOriginalFile.exists())
+ {
+ snapshotOriginalFile = null;
+ }
+ return snapshotOriginalFile;
+ }
+
+ /* (non-Javadoc)
+ * @see com.motorola.studio.android.emulator.logic.IAndroidLogicInstance#getStateData()
+ */
+ public List<File> getStateData()
+ {
+ return SdkUtils.getStateDataFiles(getName());
+ }
+
+ /* (non-Javadoc)
+ * @see com.motorola.studio.android.emulator.logic.IAndroidLogicInstance#isClean()
+ */
+ public boolean isClean()
+ {
+ boolean userdataExists = false;
+ File userdataFile = getUserdata();
+ if ((userdataFile != null) && (userdataFile.exists()))
+ {
+ userdataExists = true;
+ }
+
+ return !userdataExists;
+ }
+
+ @Override
+ public String toString()
+ {
+ // Do not use getInstanceIdentifier method here (it is used by several
+ // logs - high exposure - and leads to synchronized methods that may
+ // cause deadlocks).
+ return getName();
+ }
+
+ /*
+ * (non-Javadoc)
+ * @see com.motorola.studio.android.emulator.core.model.IAndroidEmulatorInstance#getProcess()
+ */
+ public Process getProcess()
+ {
+ return process;
+ }
+
+ /*
+ * (non-Javadoc)
+ * @see com.motorola.studio.android.emulator.core.model.IAndroidEmulatorInstance#setProcess(java.lang.Process)
+ */
+ public void setProcess(Process process)
+ {
+ this.process = process;
+
+ }
+
+ /*
+ * (non-Javadoc)
+ * @see com.motorola.studio.android.emulator.core.model.IAndroidEmulatorInstance#setWindowHandle(int)
+ */
+ public long getWindowHandle()
+ {
+ return windowHandle;
+ }
+
+ /*
+ * (non-Javadoc)
+ * @see com.motorola.studio.android.emulator.core.model.IAndroidEmulatorInstance#getWindowHandle()
+ */
+ public void setWindowHandle(long handle)
+ {
+ windowHandle = handle;
+ }
+
+ /*
+ * (non-Javadoc)
+ * @see com.motorola.studio.android.adt.ISerialNumbered#getDeviceName()
+ */
+ public String getDeviceName()
+ {
+ return getName();
+ }
+
+ /*
+ * (non-Javadoc)
+ * @see com.motorola.studio.android.emulator.core.model.IAndroidEmulatorInstance#getFullName()
+ */
+ public String getFullName()
+ {
+ String suffix = getNameSuffix();
+ if (suffix != null)
+ {
+ return getName() + " (" + suffix + ")";
+ }
+ else
+ {
+ return getName();
+ }
+ }
+
+ /*
+ * (non-Javadoc)
+ * @see org.eclipse.ui.model.IWorkbenchAdapter#getChildren(java.lang.Object)
+ */
+ public Object[] getChildren(Object o)
+ {
+ return new Object[0];
+ }
+
+ /*
+ * (non-Javadoc)
+ * @see org.eclipse.ui.model.IWorkbenchAdapter#getImageDescriptor(java.lang.Object)
+ */
+ public ImageDescriptor getImageDescriptor(Object object)
+ {
+ return null;
+ }
+
+ /*
+ * (non-Javadoc)
+ * @see org.eclipse.ui.model.IWorkbenchAdapter#getLabel(java.lang.Object)
+ */
+ public String getLabel(Object o)
+ {
+ return getName();
+ }
+
+ /*
+ * (non-Javadoc)
+ * @see org.eclipse.ui.model.IWorkbenchAdapter#getParent(java.lang.Object)
+ */
+ public Object getParent(Object o)
+ {
+ return null;
+ }
+
+ /*
+ * (non-Javadoc)
+ * @see com.motorola.studio.android.adt.ISerialNumbered#getSerialNumber()
+ */
+ public String getSerialNumber()
+ {
+ return DDMSFacade.getSerialNumberByName(getName());
+ }
+
+ /*
+ * (non-Javadoc)
+ * @see com.motorola.studio.android.emulator.core.model.IAndroidEmulatorInstance#isAvailable()
+ */
+ public boolean isAvailable()
+ {
+ return !getStatus().equals(EmulatorPlugin.STATUS_NOT_AVAILABLE);
+ }
+
+ /* (non-Javadoc)
+ * @see com.motorola.studio.android.emulator.logic.IAndroidLogicInstance#getCommandLineArgumentsAsProperties()
+ */
+ public Properties getCommandLineArgumentsAsProperties()
+ {
+ return StartupOptionsMgt.parseCommandLine(getCommandLineArguments());
+
+ }
+
+ public Composite getComposite()
+ {
+ return composite;
+ }
+
+ public void setComposite(Composite composite)
+ {
+ this.composite = composite;
+ }
+
+}
\ No newline at end of file |