Merge branch 'activiti6' of https://github.com/Activiti/Activiti into activiti6

# By Tijs Rademakers
# Via Tijs Rademakers
* 'activiti6' of https://github.com/Activiti/Activiti:
  First batch of call activity support
  Call activity work in progress

modules/activiti-engine/src/main/java/org/activiti/engine/impl/agenda/EndExecutionOperation.java

@@ -3,12 +3,16 @@ package org.activiti.engine.impl.agenda;
 import java.util.Collection;
 
 import org.activiti.bpmn.model.EndEvent;
+import org.activiti.bpmn.model.FlowNode;
 import org.activiti.bpmn.model.SubProcess;
+import org.activiti.engine.ActivitiException;
 import org.activiti.engine.impl.bpmn.behavior.MultiInstanceActivityBehavior;
 import org.activiti.engine.impl.interceptor.CommandContext;
 import org.activiti.engine.impl.persistence.entity.ExecutionEntity;
 import org.activiti.engine.impl.persistence.entity.ExecutionEntityManager;
 import org.activiti.engine.impl.pvm.delegate.ActivityExecution;
+import org.activiti.engine.impl.pvm.delegate.SubProcessActivityBehavior;
+import org.activiti.engine.impl.pvm.runtime.InterpretableExecution;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -29,8 +33,7 @@ public class EndExecutionOperation extends AbstractOperation {
         ExecutionEntityManager executionEntityManager = commandContext.getExecutionEntityManager();
         ExecutionEntity executionEntity = (ExecutionEntity) execution; // TODO: dont like the cast here
 
-        // Find parent execution. If not found, it's the process instance and
-        // other logic needs to happen
+        // Find parent execution. If not found, it's the process instance and other logic needs to happen
         ExecutionEntity parentExecution = null;
         if (executionEntity.getParentId() != null) {
             parentExecution = executionEntityManager.get(executionEntity.getParentId());
@@ -79,11 +82,27 @@ public class EndExecutionOperation extends AbstractOperation {
             String processInstanceId = executionEntity.getId(); // No parent execution == process instance id
             logger.debug("No parent execution found. Verifying if process instance {} can be stopped.", processInstanceId);
 
-            // TODO: optimisation can be made by keeping the nr of active
-            // executions directly on the process instance in db
+            InterpretableExecution superExecution = executionEntity.getSuperExecution();
+            SubProcessActivityBehavior subProcessActivityBehavior = null;
+
+            // copy variables before destroying the ended sub process instance
+            if (superExecution != null) {
+                FlowNode superExecutionElement = (FlowNode) superExecution.getCurrentFlowElement();
+                subProcessActivityBehavior = (SubProcessActivityBehavior) superExecutionElement.getBehavior();
+                try {
+                    subProcessActivityBehavior.completing(superExecution, executionEntity);
+                } catch (RuntimeException e) {
+                    logger.error("Error while completing sub process of execution {}", executionEntity, e);
+                    throw e;
+                } catch (Exception e) {
+                    logger.error("Error while completing sub process of execution {}", executionEntity, e);
+                    throw new ActivitiException("Error while completing sub process of execution " + executionEntity, e);
+                }
+            }
+            
+            // TODO: optimisation can be made by keeping the nr of active executions directly on the process instance in db
 
-            // TODO: verify how many executions are still active in the process
-            // instance, and stop the process instance otherwise
+            // TODO: verify how many executions are still active in the process instance, and stop the process instance otherwise
             Collection<ExecutionEntity> executions = executionEntityManager.findChildExecutionsByProcessInstanceId(processInstanceId);
             int activeExecutions = 0;
             for (ExecutionEntity execution : executions) {
@@ -98,6 +117,20 @@ public class EndExecutionOperation extends AbstractOperation {
             } else {
                 logger.debug("Active executions found. Process instance {} will not be ended.", processInstanceId);
             }
+
+            // and trigger execution afterwards
+            if (superExecution != null) {
+                superExecution.setSubProcessInstance(null);
+                try {
+                    subProcessActivityBehavior.completed(superExecution);
+                } catch (RuntimeException e) {
+                    logger.error("Error while completing sub process of execution {}", executionEntity, e);
+                    throw e;
+                } catch (Exception e) {
+                    logger.error("Error while completing sub process of execution {}", executionEntity, e);
+                    throw new ActivitiException("Error while completing sub process of execution " + executionEntity, e);
+                }
+            }
         }
     }
 

modules/activiti-engine/src/main/java/org/activiti/engine/impl/bpmn/behavior/CallActivityBehavior.java

@@ -13,33 +13,41 @@
 
 package org.activiti.engine.impl.bpmn.behavior;
 
-import java.util.ArrayList;
 import java.util.List;
 
+import org.activiti.bpmn.model.CallActivity;
+import org.activiti.bpmn.model.FlowElement;
+import org.activiti.bpmn.model.IOParameter;
 import org.activiti.bpmn.model.MapExceptionEntry;
+import org.activiti.bpmn.model.Process;
 import org.activiti.engine.ActivitiException;
 import org.activiti.engine.ProcessEngineConfiguration;
 import org.activiti.engine.delegate.DelegateExecution;
 import org.activiti.engine.delegate.Expression;
-import org.activiti.engine.impl.bpmn.data.AbstractDataAssociation;
+import org.activiti.engine.delegate.event.ActivitiEventType;
+import org.activiti.engine.delegate.event.impl.ActivitiEventBuilder;
 import org.activiti.engine.impl.bpmn.helper.ErrorPropagation;
 import org.activiti.engine.impl.context.Context;
+import org.activiti.engine.impl.el.ExpressionManager;
+import org.activiti.engine.impl.persistence.entity.ExecutionEntity;
 import org.activiti.engine.impl.persistence.entity.ProcessDefinitionEntity;
-import org.activiti.engine.impl.pvm.PvmProcessInstance;
 import org.activiti.engine.impl.pvm.delegate.ActivityExecution;
 import org.activiti.engine.impl.pvm.delegate.SubProcessActivityBehavior;
+import org.activiti.engine.impl.util.ProcessDefinitionUtil;
+import org.apache.commons.lang3.StringUtils;
 
 /**
  * Implementation of the BPMN 2.0 call activity (limited currently to calling a
  * subprocess and not (yet) a global task).
  * 
  * @author Joram Barrez
+ * @author Tijs Rademakers
  */
 public class CallActivityBehavior extends AbstractBpmnActivityBehavior implements SubProcessActivityBehavior {
 
+    private static final long serialVersionUID = 1L;
+    
     protected String processDefinitonKey;
-    private List<AbstractDataAssociation> dataInputAssociations = new ArrayList<AbstractDataAssociation>();
-    private List<AbstractDataAssociation> dataOutputAssociations = new ArrayList<AbstractDataAssociation>();
     private Expression processDefinitionExpression;
     protected List<MapExceptionEntry> mapExceptions;
 
@@ -49,83 +57,93 @@ public class CallActivityBehavior extends AbstractBpmnActivityBehavior implement
     }
 
     public CallActivityBehavior(Expression processDefinitionExpression, List<MapExceptionEntry> mapExceptions) {
-        super();
         this.processDefinitionExpression = processDefinitionExpression;
         this.mapExceptions = mapExceptions;
     }
 
-    public void addDataInputAssociation(AbstractDataAssociation dataInputAssociation) {
-        this.dataInputAssociations.add(dataInputAssociation);
-    }
-
-    public void addDataOutputAssociation(AbstractDataAssociation dataOutputAssociation) {
-        this.dataOutputAssociations.add(dataOutputAssociation);
-    }
-
     public void execute(ActivityExecution execution) {
 
-        String processDefinitonKey = this.processDefinitonKey;
+        String finalProcessDefinitonKey = null;
         if (processDefinitionExpression != null) {
-            processDefinitonKey = (String) processDefinitionExpression.getValue(execution);
+            finalProcessDefinitonKey = (String) processDefinitionExpression.getValue(execution);
+        } else {
+            finalProcessDefinitonKey = processDefinitonKey;
         }
 
         ProcessDefinitionEntity processDefinition = null;
         if (execution.getTenantId() == null || ProcessEngineConfiguration.NO_TENANT_ID.equals(execution.getTenantId())) {
-            processDefinition = Context.getProcessEngineConfiguration().getDeploymentManager().findDeployedLatestProcessDefinitionByKey(processDefinitonKey);
+            processDefinition = Context.getProcessEngineConfiguration().getDeploymentManager().findDeployedLatestProcessDefinitionByKey(finalProcessDefinitonKey);
         } else {
-            processDefinition = Context.getProcessEngineConfiguration().getDeploymentManager().findDeployedLatestProcessDefinitionByKeyAndTenantId(processDefinitonKey, execution.getTenantId());
+            processDefinition = Context.getProcessEngineConfiguration().getDeploymentManager().findDeployedLatestProcessDefinitionByKeyAndTenantId(finalProcessDefinitonKey, execution.getTenantId());
+        }
+        
+        // Get model from cache
+        Process subProcess = ProcessDefinitionUtil.getProcess(processDefinition.getId());
+        if (subProcess == null) {
+            throw new ActivitiException("Cannot start a sub process instance. Process model " + processDefinition.getName() + " (id = " + processDefinition.getId() + ") could not be found");
+        }
+
+        FlowElement initialFlowElement = subProcess.getInitialFlowElement();
+        if (initialFlowElement == null) {
+            throw new ActivitiException("No start element found for process definition " + processDefinition.getId());
         }
 
-        // Do not start a process instance if the process definition is
-        // suspended
+        // Do not start a process instance if the process definition is suspended
         if (processDefinition.isSuspended()) {
             throw new ActivitiException("Cannot start process instance. Process definition " + processDefinition.getName() + " (id = " + processDefinition.getId() + ") is suspended");
         }
 
-        PvmProcessInstance subProcessInstance = execution.createSubProcessInstance(processDefinition);
+        ExecutionEntity executionEntity = (ExecutionEntity) execution;
+        CallActivity callActivity = (CallActivity) executionEntity.getCurrentFlowElement();
+        
+        ExecutionEntity subProcessInstance = createSubProcessInstance(processDefinition, executionEntity, initialFlowElement);
 
         // copy process variables
-        for (AbstractDataAssociation dataInputAssociation : dataInputAssociations) {
+        ExpressionManager expressionManager = Context.getProcessEngineConfiguration().getExpressionManager();
+        for (IOParameter ioParameter : callActivity.getInParameters()) {
             Object value = null;
-            if (dataInputAssociation.getSourceExpression() != null) {
-                value = dataInputAssociation.getSourceExpression().getValue(execution);
+            if (StringUtils.isNotEmpty(ioParameter.getSourceExpression())) {
+                Expression expression = expressionManager.createExpression(ioParameter.getSourceExpression().trim());
+                value = expression.getValue(execution);
+                
             } else {
-                value = execution.getVariable(dataInputAssociation.getSource());
+                value = execution.getVariable(ioParameter.getSource());
             }
-            subProcessInstance.setVariable(dataInputAssociation.getTarget(), value);
+            subProcessInstance.setVariable(ioParameter.getTarget(), value);
         }
 
+        // Create the first execution that will visit all the process definition elements
+        ExecutionEntity subProcessInitialExecution = subProcessInstance.createExecution();
+        subProcessInitialExecution.setCurrentFlowElement(initialFlowElement);
+        
         try {
-            subProcessInstance.start();
+            Context.getAgenda().planContinueProcessOperation(subProcessInitialExecution);
         } catch (Exception e) {
-            if (!ErrorPropagation.mapException(e, execution, mapExceptions, true))
+            if (!ErrorPropagation.mapException(e, subProcessInitialExecution, mapExceptions, true)) {
                 throw new ActivitiException("Error executing call activity", e);
-
+            }
         }
 
     }
 
-    public void setProcessDefinitonKey(String processDefinitonKey) {
-        this.processDefinitonKey = processDefinitonKey;
-    }
-
-    public String getProcessDefinitonKey() {
-        return processDefinitonKey;
-    }
-
     public void completing(DelegateExecution execution, DelegateExecution subProcessInstance) throws Exception {
         // only data. no control flow available on this execution.
 
+        ExpressionManager expressionManager = Context.getProcessEngineConfiguration().getExpressionManager();
+        
         // copy process variables
-        for (AbstractDataAssociation dataOutputAssociation : dataOutputAssociations) {
+        ExecutionEntity executionEntity = (ExecutionEntity) execution;
+        CallActivity callActivity = (CallActivity) executionEntity.getCurrentFlowElement();
+        for (IOParameter ioParameter : callActivity.getOutParameters()) {
             Object value = null;
-            if (dataOutputAssociation.getSourceExpression() != null) {
-                value = dataOutputAssociation.getSourceExpression().getValue(subProcessInstance);
+            if (StringUtils.isNotEmpty(ioParameter.getSourceExpression())) {
+                Expression expression = expressionManager.createExpression(ioParameter.getSourceExpression().trim());
+                value = expression.getValue(subProcessInstance);
+                
             } else {
-                value = subProcessInstance.getVariable(dataOutputAssociation.getSource());
+                value = subProcessInstance.getVariable(ioParameter.getSource());
             }
-
-            execution.setVariable(dataOutputAssociation.getTarget(), value);
+            execution.setVariable(ioParameter.getTarget(), value);
         }
     }
 
@@ -133,5 +151,43 @@ public class CallActivityBehavior extends AbstractBpmnActivityBehavior implement
         // only control flow. no sub process instance data available
         leave(execution);
     }
+    
+    protected ExecutionEntity createSubProcessInstance(ProcessDefinitionEntity processDefinitionEntity, 
+            ExecutionEntity processInstanceEntity, FlowElement initialFlowElement) {
+
+        ExecutionEntity subProcessInstance = new ExecutionEntity();
+        subProcessInstance.setProcessDefinitionId(processDefinitionEntity.getId());
+        subProcessInstance.setSuperExecution(processInstanceEntity);
+        subProcessInstance.setScope(true); // process instance is always a scope for all child executions
+
+        // Inherit tenant id (if any)
+        if (processDefinitionEntity.getTenantId() != null) {
+            subProcessInstance.setTenantId(processDefinitionEntity.getTenantId());
+        }
+
+        // Store in database
+        Context.getCommandContext().getExecutionEntityManager().insert(subProcessInstance);
+
+        subProcessInstance.setProcessInstanceId(subProcessInstance.getId());
+        processInstanceEntity.setSubProcessInstance(subProcessInstance);
 
+        // Fire events manage bidirectional super-subprocess relation
+        Context.getCommandContext().getHistoryManager().recordSubProcessInstanceStart(processInstanceEntity, 
+                subProcessInstance, initialFlowElement);
+
+        if (Context.getProcessEngineConfiguration() != null && Context.getProcessEngineConfiguration().getEventDispatcher().isEnabled()) {
+            Context.getProcessEngineConfiguration().getEventDispatcher().dispatchEvent(
+                    ActivitiEventBuilder.createEntityEvent(ActivitiEventType.ENTITY_CREATED, subProcessInstance));
+        }
+
+        return subProcessInstance;
+    }
+
+    public void setProcessDefinitonKey(String processDefinitonKey) {
+        this.processDefinitonKey = processDefinitonKey;
+    }
+
+    public String getProcessDefinitonKey() {
+        return processDefinitonKey;
+    }
 }

modules/activiti-engine/src/main/java/org/activiti/engine/impl/bpmn/parser/factory/DefaultActivityBehaviorFactory.java

@@ -16,7 +16,6 @@ import java.util.List;
 
 import org.activiti.bpmn.model.Activity;
 import org.activiti.bpmn.model.BoundaryEvent;
-import org.activiti.bpmn.model.BpmnModel;
 import org.activiti.bpmn.model.BusinessRuleTask;
 import org.activiti.bpmn.model.CallActivity;
 import org.activiti.bpmn.model.CancelEventDefinition;
@@ -25,7 +24,6 @@ import org.activiti.bpmn.model.ErrorEventDefinition;
 import org.activiti.bpmn.model.EventGateway;
 import org.activiti.bpmn.model.ExclusiveGateway;
 import org.activiti.bpmn.model.FieldExtension;
-import org.activiti.bpmn.model.IOParameter;
 import org.activiti.bpmn.model.InclusiveGateway;
 import org.activiti.bpmn.model.IntermediateCatchEvent;
 import org.activiti.bpmn.model.ManualTask;
@@ -80,12 +78,10 @@ import org.activiti.engine.impl.bpmn.behavior.TerminateEndEventActivityBehavior;
 import org.activiti.engine.impl.bpmn.behavior.TransactionActivityBehavior;
 import org.activiti.engine.impl.bpmn.behavior.UserTaskActivityBehavior;
 import org.activiti.engine.impl.bpmn.behavior.WebServiceActivityBehavior;
-import org.activiti.engine.impl.bpmn.data.SimpleDataInputAssociation;
 import org.activiti.engine.impl.bpmn.helper.ClassDelegate;
 import org.activiti.engine.impl.bpmn.parser.CompensateEventDefinition;
 import org.activiti.engine.impl.bpmn.parser.EventSubscriptionDeclaration;
 import org.activiti.engine.impl.bpmn.parser.FieldDeclaration;
-import org.activiti.engine.impl.bpmn.webservice.MessageImplicitDataOutputAssociation;
 import org.activiti.engine.impl.cfg.ProcessEngineConfigurationImpl;
 import org.activiti.engine.impl.pvm.delegate.ActivityBehavior;
 import org.activiti.engine.impl.scripting.ScriptingEngines;
@@ -347,24 +343,6 @@ public class DefaultActivityBehaviorFactory extends AbstractBehaviorFactory impl
             callActivityBehaviour = new CallActivityBehavior(callActivity.getCalledElement(), callActivity.getMapExceptions());
         }
 
-        for (IOParameter ioParameter : callActivity.getInParameters()) {
-            if (StringUtils.isNotEmpty(ioParameter.getSourceExpression())) {
-                Expression expression = expressionManager.createExpression(ioParameter.getSourceExpression().trim());
-                callActivityBehaviour.addDataInputAssociation(new SimpleDataInputAssociation(expression, ioParameter.getTarget()));
-            } else {
-                callActivityBehaviour.addDataInputAssociation(new SimpleDataInputAssociation(ioParameter.getSource(), ioParameter.getTarget()));
-            }
-        }
-
-        for (IOParameter ioParameter : callActivity.getOutParameters()) {
-            if (StringUtils.isNotEmpty(ioParameter.getSourceExpression())) {
-                Expression expression = expressionManager.createExpression(ioParameter.getSourceExpression().trim());
-                callActivityBehaviour.addDataOutputAssociation(new MessageImplicitDataOutputAssociation(ioParameter.getTarget(), expression));
-            } else {
-                callActivityBehaviour.addDataOutputAssociation(new MessageImplicitDataOutputAssociation(ioParameter.getTarget(), ioParameter.getSource()));
-            }
-        }
-
         return callActivityBehaviour;
     }
 

modules/activiti-engine/src/main/java/org/activiti/engine/impl/bpmn/parser/handler/CallActivityParseHandler.java

@@ -12,11 +12,9 @@
  */
 package org.activiti.engine.impl.bpmn.parser.handler;
 
-import org.activiti.bpmn.constants.BpmnXMLConstants;
 import org.activiti.bpmn.model.BaseElement;
 import org.activiti.bpmn.model.CallActivity;
 import org.activiti.engine.impl.bpmn.parser.BpmnParse;
-import org.activiti.engine.impl.pvm.process.ActivityImpl;
 
 /**
  * @author Joram Barrez
@@ -28,11 +26,7 @@ public class CallActivityParseHandler extends AbstractActivityBpmnParseHandler<C
     }
 
     protected void executeParse(BpmnParse bpmnParse, CallActivity callActivity) {
-
-        ActivityImpl activity = createActivityOnCurrentScope(bpmnParse, callActivity, BpmnXMLConstants.ELEMENT_CALL_ACTIVITY);
-        activity.setScope(true);
-        activity.setAsync(callActivity.isAsynchronous());
-        activity.setActivityBehavior(bpmnParse.getActivityBehaviorFactory().createCallActivityBehavior(callActivity));
+        callActivity.setBehavior(bpmnParse.getActivityBehaviorFactory().createCallActivityBehavior(callActivity));
     }
 
 }

modules/activiti-engine/src/main/java/org/activiti/engine/impl/bpmn/parser/handler/StartEventParseHandler.java

@@ -28,8 +28,7 @@ public class StartEventParseHandler extends AbstractActivityBpmnParseHandler<Sta
 
     private static Logger logger = LoggerFactory.getLogger(StartEventParseHandler.class);
 
-    // public static final String PROPERTYNAME_INITIATOR_VARIABLE_NAME =
-    // "initiatorVariableName";
+    // public static final String PROPERTYNAME_INITIATOR_VARIABLE_NAME = "initiatorVariableName";
     // public static final String PROPERTYNAME_INITIAL = "initial";
 
     @Override
@@ -49,7 +48,11 @@ public class StartEventParseHandler extends AbstractActivityBpmnParseHandler<Sta
             element.setBehavior(bpmnParse.getActivityBehaviorFactory().createNoneStartEventActivityBehavior(element));
         }
         
-        bpmnParse.getCurrentProcess().setInitialFlowElement(element);
+        if (element.getSubProcess() == null && (CollectionUtils.isEmpty(element.getEventDefinitions()) ||
+                bpmnParse.getCurrentProcess().getInitialFlowElement() == null)) {
+            
+            bpmnParse.getCurrentProcess().setInitialFlowElement(element);
+        }
     }
 
     // @Override

modules/activiti-engine/src/main/java/org/activiti/engine/impl/history/DefaultHistoryManager.java

@@ -38,7 +38,6 @@ import org.activiti.engine.impl.persistence.entity.HistoricVariableInstanceEntit
 import org.activiti.engine.impl.persistence.entity.IdentityLinkEntity;
 import org.activiti.engine.impl.persistence.entity.TaskEntity;
 import org.activiti.engine.impl.persistence.entity.VariableInstanceEntity;
-import org.activiti.engine.impl.pvm.process.ActivityImpl;
 import org.activiti.engine.impl.pvm.runtime.InterpretableExecution;
 import org.activiti.engine.task.Event;
 import org.slf4j.Logger;
@@ -154,7 +153,7 @@ public class DefaultHistoryManager extends AbstractManager implements HistoryMan
             historicActivityInstance.setExecutionId(executionId);
             historicActivityInstance.setActivityId(startElement.getId());
             historicActivityInstance.setActivityName(startElement.getName());
-            historicActivityInstance.setActivityType(startElement.getClass().getName());
+            historicActivityInstance.setActivityType(parseActivityType(startElement));
             Date now = Context.getProcessEngineConfiguration().getClock().getCurrentTime();
             historicActivityInstance.setStartTime(now);
 
@@ -176,17 +175,14 @@ public class DefaultHistoryManager extends AbstractManager implements HistoryMan
      * org.activiti.engine.impl.persistence.entity.ExecutionEntity)
      */
     @Override
-    public void recordSubProcessInstanceStart(ExecutionEntity parentExecution, ExecutionEntity subProcessInstance) {
+    public void recordSubProcessInstanceStart(ExecutionEntity parentExecution, ExecutionEntity subProcessInstance, FlowElement initialElement) {
         if (isHistoryLevelAtLeast(HistoryLevel.ACTIVITY)) {
 
             HistoricProcessInstanceEntity historicProcessInstance = new HistoricProcessInstanceEntity((ExecutionEntity) subProcessInstance);
 
-            ActivityImpl initialActivity = subProcessInstance.getActivity();
-            // Fix for ACT-1728: startActivityId not initialized with
-            // subprocess-instance
+            // Fix for ACT-1728: startActivityId not initialized with subprocess instance
             if (historicProcessInstance.getStartActivityId() == null) {
-                historicProcessInstance.setStartActivityId(subProcessInstance.getProcessDefinition().getInitial().getId());
-                initialActivity = subProcessInstance.getProcessDefinition().getInitial();
+                historicProcessInstance.setStartActivityId(initialElement.getId());
             }
             getDbSqlSession().insert(historicProcessInstance);
 
@@ -205,9 +201,9 @@ public class DefaultHistoryManager extends AbstractManager implements HistoryMan
             historicActivityInstance.setProcessDefinitionId(subProcessInstance.getProcessDefinitionId());
             historicActivityInstance.setProcessInstanceId(subProcessInstance.getProcessInstanceId());
             historicActivityInstance.setExecutionId(subProcessInstance.getId());
-            historicActivityInstance.setActivityId(initialActivity.getId());
-            historicActivityInstance.setActivityName((String) initialActivity.getProperty("name"));
-            historicActivityInstance.setActivityType((String) initialActivity.getProperty("type"));
+            historicActivityInstance.setActivityId(initialElement.getId());
+            historicActivityInstance.setActivityName(initialElement.getName());      
+            historicActivityInstance.setActivityType(parseActivityType(initialElement));
             Date now = Context.getProcessEngineConfiguration().getClock().getCurrentTime();
             historicActivityInstance.setStartTime(now);
 
@@ -241,9 +237,7 @@ public class DefaultHistoryManager extends AbstractManager implements HistoryMan
                 historicActivityInstance.setExecutionId(executionId);
                 historicActivityInstance.setActivityId(executionEntity.getCurrentActivityId());
                 historicActivityInstance.setActivityName(executionEntity.getCurrentFlowElement().getName());
-                String elementType = executionEntity.getCurrentFlowElement().getClass().getSimpleName();
-                elementType = elementType.substring(0, 1).toLowerCase() + elementType.substring(1);
-                historicActivityInstance.setActivityType(elementType);
+                historicActivityInstance.setActivityType(parseActivityType(executionEntity.getCurrentFlowElement()));
                 historicActivityInstance.setStartTime(Context.getProcessEngineConfiguration().getClock().getCurrentTime());
 
                 // Inherit tenant id (if applicable)
@@ -912,4 +906,10 @@ public class DefaultHistoryManager extends AbstractManager implements HistoryMan
         // TODO Auto-generated method stub
 
     }
+    
+    protected String parseActivityType(FlowElement element) {
+        String elementType = element.getClass().getSimpleName();
+        elementType = elementType.substring(0, 1).toLowerCase() + elementType.substring(1);
+        return elementType;
+    }
 }

modules/activiti-engine/src/main/java/org/activiti/engine/impl/history/HistoryManager.java

@@ -49,7 +49,8 @@ public interface HistoryManager extends Session {
      * calledProcessinstanceId on the current active activity's historic
      * counterpart. Only effective when activity history is enabled.
      */
-    public abstract void recordSubProcessInstanceStart(ExecutionEntity parentExecution, ExecutionEntity subProcessInstance);
+    public abstract void recordSubProcessInstanceStart(ExecutionEntity parentExecution, 
+            ExecutionEntity subProcessInstance, FlowElement initialFlowElement);
 
     /**
      * Record the start of an activitiy, if activity history is enabled.

modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/ExecutionEntity.java

@@ -309,25 +309,6 @@ public class ExecutionEntity extends VariableScopeImpl implements ActivityExecut
         return createdExecution;
     }
 
-    public PvmProcessInstance createSubProcessInstance(PvmProcessDefinition processDefinition) {
-        ExecutionEntity subProcessInstance = newExecution();
-
-        // manage bidirectional super-subprocess relation
-        subProcessInstance.setSuperExecution(this);
-        this.setSubProcessInstance(subProcessInstance);
-
-        // Initialize the new execution
-        subProcessInstance.setProcessDefinition((ProcessDefinitionImpl) processDefinition);
-        subProcessInstance.setProcessInstance(subProcessInstance);
-
-        Context.getCommandContext().getHistoryManager().recordSubProcessInstanceStart(this, subProcessInstance);
-
-        if (Context.getProcessEngineConfiguration() != null && Context.getProcessEngineConfiguration().getEventDispatcher().isEnabled()) {
-            Context.getProcessEngineConfiguration().getEventDispatcher().dispatchEvent(ActivitiEventBuilder.createEntityEvent(ActivitiEventType.ENTITY_CREATED, subProcessInstance));
-        }
-        return subProcessInstance;
-    }
-
     protected ExecutionEntity newExecution() {
         ExecutionEntity newExecution = new ExecutionEntity();
         newExecution.executions = new ArrayList<ExecutionEntity>();

modules/activiti-engine/src/main/java/org/activiti/engine/impl/pvm/delegate/ActivityExecution.java

@@ -17,8 +17,6 @@ import java.util.List;
 import org.activiti.bpmn.model.FlowElement;
 import org.activiti.engine.delegate.DelegateExecution;
 import org.activiti.engine.impl.pvm.PvmActivity;
-import org.activiti.engine.impl.pvm.PvmProcessDefinition;
-import org.activiti.engine.impl.pvm.PvmProcessInstance;
 import org.activiti.engine.impl.pvm.PvmTransition;
 
 /**
@@ -54,15 +52,6 @@ public interface ActivityExecution extends DelegateExecution {
      */
     ActivityExecution createExecution();
 
-    /**
-     * creates a new sub process instance. The current execution will be the
-     * super execution of the created execution.
-     * 
-     * @param processDefinition
-     *            The {@link PvmProcessDefinition} of the subprocess.
-     */
-    PvmProcessInstance createSubProcessInstance(PvmProcessDefinition processDefinition);
-
     /**
      * returns the parent of this execution, or null if there no parent.
      */