* some changes to AMM POC Control Sender base sample code to make statemachines more clear

Signed-off-by: christian mueller <christian.ei.mueller@bmw.de>

2 files changed, 441 insertions, 72 deletions

diff --git a/PluginControlInterface/include/CAmControlSenderBase.h b/PluginControlInterface/include/CAmControlSenderBase.h
index 7b07dfc..893cbaa 100644
--- a/PluginControlInterface/include/CAmControlSenderBase.h
+++ b/PluginControlInterface/include/CAmControlSenderBase.h
@@ -78,6 +78,10 @@ public:
 
 private:
     IAmControlReceive * mControlReceiveInterface;
+
+    void disconnect(am_mainConnectionID_t connectionID);
+    void connect(am_sourceID_t sourceID, am_sinkID_t sinkID, am_mainConnectionID_t mainConnectionID);
+
     struct handleStatus
     {
         bool status;
@@ -148,10 +152,78 @@ private:
         }
     };
 
+    enum cs_stateflow_e
+    {
+        SF_NONE,
+        SF_CONNECT,
+        SF_NAVI,
+        SF_TA
+    };
+
+    enum cs_connectSf_e
+    {
+        SFC_RAMP_DOWN,
+        SFC_SOURCE_STATE_OFF,
+        SFC_DISCONNECT,
+        SFC_CONNECT,
+        SFC_SOURCE_STATE_ON,
+        SFC_RAMP_UP,
+        SFC_FINISHED
+    };
+
+    enum cs_naviSf_e
+    {
+        NAVC_RAMP_DOWN,
+        NAVC_CONNECT,
+        NAVC_SOURCE_STATE_ON,
+        NAVC_RAMP_UP,
+        NAVC_WAIT_STATE,
+        NAVC_RAMP_DOWN_AGAIN,
+        NAVC_SOURCE_VOLUME_BACK,
+        NAVC_SOURCE_ACTIVITY_BACK,
+        NAVC_DISCONNECT,
+        NAVC_FINISHED
+    };
+
+    enum cs_trafficSf_e
+    {
+        TA_RAMP_DOWN,
+        TA_CONNECT,
+        TA_SOURCE_STATE_ON,
+        TA_RAMP_UP,
+        TA_WAIT_STATE,
+        TA_RAMP_DOWN_AGAIN,
+        TA_SOURCE_STATE_OFF,
+        TA_SOURCE_STATE_OLD_OFF,
+        TA_DISCONNECT,
+        TA_FINISHED
+    };
+
+    struct cs_connectData_s
+    {
+        am_mainConnectionID_t currentMainConnection;
+        am_mainConnectionID_t newMainConnection;
+        am_sourceID_t oldSourceID;
+        am_sinkID_t sinkID;
+        am_sourceID_t sourceID;
+    };
+
+    void callStateFlowHandler();
+    void callConnectHandler();
+    void callNaviHandler();
+    void callTAHandler();
+
     std::vector<mainConnectionSet> mListOpenConnections;
     std::vector<mainConnectionSet> mListOpenDisconnections;
     std::vector<mainVolumeSet> mListOpenVolumeChanges;
     std::vector<mainSinkSoundPropertySet> mListMainSoundPropertyChanges;
+
+    cs_connectSf_e mConnectSf;
+    cs_naviSf_e mNaviSf;
+    cs_trafficSf_e mTrafficSf;
+    cs_connectData_s mConnectData;
+    cs_stateflow_e mStateflow;
+
 };
 
 #endif /* CONTROLSENDER_H_ */
diff --git a/PluginControlInterface/src/CAmControlSenderBase.cpp b/PluginControlInterface/src/CAmControlSenderBase.cpp
index 34d6852..2878306 100644
--- a/PluginControlInterface/src/CAmControlSenderBase.cpp
+++ b/PluginControlInterface/src/CAmControlSenderBase.cpp
@@ -37,7 +37,12 @@ CAmControlSenderBase::CAmControlSenderBase() :
         mControlReceiveInterface(NULL), //
         mListOpenConnections(), //
         mListOpenDisconnections(), //
-        mListOpenVolumeChanges()
+        mListOpenVolumeChanges(),//
+        mConnectSf (SFC_RAMP_DOWN), //
+        mNaviSf(NAVC_RAMP_DOWN), //
+        mTrafficSf(TA_RAMP_DOWN),//
+        mConnectData(), //
+        mStateflow(SF_NONE)
 {
 }
 
@@ -49,6 +54,17 @@ am_Error_e CAmControlSenderBase::startupController(IAmControlReceive *controlrec
 {
     assert(controlreceiveinterface);
     mControlReceiveInterface = controlreceiveinterface;
+    am_sourceClass_t sourceClassID;
+    am_SourceClass_s sourceClass;
+    sourceClass.name="player";
+    sourceClass.sourceClassID=1;
+    mControlReceiveInterface->enterSourceClassDB(sourceClassID,sourceClass);
+    sourceClass.name="navi";
+    sourceClass.sourceClassID=2;
+    mControlReceiveInterface->enterSourceClassDB(sourceClassID,sourceClass);
+    sourceClass.name="ta";
+    sourceClass.sourceClassID=3;
+    mControlReceiveInterface->enterSourceClassDB(sourceClassID,sourceClass);
     //here is a good place to insert SystemProperties into the database...
     //and might be a good place to insert the Source and Sink CLasses as well
     return E_NOT_USED;
@@ -63,90 +79,126 @@ void CAmControlSenderBase::setControllerReady()
 
 am_Error_e CAmControlSenderBase::hookUserConnectionRequest(const am_sourceID_t sourceID, const am_sinkID_t sinkID, am_mainConnectionID_t & mainConnectionID)
 {
+    if (mStateflow!=SF_NONE)
+        return (E_NOT_POSSIBLE);
+
     std::vector<am_Route_s> listRoutes;
     std::vector<am_connectionID_t> listConnectionIDs;
-    am_Handle_s handle;
-    mControlReceiveInterface->getRoute(true, sourceID, sinkID, listRoutes);
+    am_SourceClass_s sourceClass, tempSourceClass;
+    bool exististingConnection(false);
+    mControlReceiveInterface->getRoute(false, sourceID, sinkID, listRoutes);
     if (listRoutes.empty())
         return (E_NOT_POSSIBLE);
 
     std::vector<am_MainConnection_s> listAllMainConnections;
     mControlReceiveInterface->getListMainConnections(listAllMainConnections);
+    mControlReceiveInterface->getSourceClassInfoDB(sourceID, sourceClass);
+
+    //go through all connections
     std::vector<am_MainConnection_s>::iterator itAll(listAllMainConnections.begin());
     for (; itAll != listAllMainConnections.end(); ++itAll)
     {
         if (itAll->sinkID == sinkID && itAll->sourceID == sourceID)
             return (E_ALREADY_EXISTS);
-    }
 
-    std::vector<handleStatus> listHandleStaus;
-    std::vector<am_RoutingElement_s>::iterator it(listRoutes[0].route.begin());
-    for (; it != listRoutes[0].route.end(); ++it)
-    {
-        am_connectionID_t connectionID;
-        mControlReceiveInterface->connect(handle, connectionID, it->connectionFormat, it->sourceID, it->sinkID);
-        handleStatus status;
-        status.handle = handle;
-        status.status = false;
-        listHandleStaus.push_back(status);
-        listConnectionIDs.push_back(connectionID);
+        //check if there is already an existing connection
+        mControlReceiveInterface->getSourceClassInfoDB(itAll->sourceID, tempSourceClass);
+        if (tempSourceClass.sourceClassID == 1)
+        {
+            mConnectData.currentMainConnection=itAll->mainConnectionID;
+            exististingConnection=true;
+            mConnectData.oldSourceID=itAll->sourceID;
+        }
     }
+
     am_MainConnection_s mainConnectionData;
     mainConnectionData.mainConnectionID = 0;
     mainConnectionData.sinkID = sinkID;
     mainConnectionData.sourceID = sourceID;
     mainConnectionData.connectionState = CS_CONNECTING;
     mainConnectionData.delay = 0;
-    mainConnectionData.listConnectionID = listConnectionIDs;
+
     mControlReceiveInterface->enterMainConnectionDB(mainConnectionData, mainConnectionID);
-    mainConnectionSet set;
-    set.connectionID = mainConnectionID;
-    set.listHandleStaus = listHandleStaus;
-    mListOpenConnections.push_back(set);
-    return E_OK;
+    mConnectData.newMainConnection=mainConnectionID;
+    mConnectData.sourceID=sourceID;
+    mConnectData.sinkID=sinkID;
+
+    if(sourceClass.sourceClassID==1)
+    {
+        if(exististingConnection)
+            mConnectSf=SFC_RAMP_DOWN;
+        else
+            mConnectSf=SFC_CONNECT;
+
+        mStateflow=SF_CONNECT;
+    }
+    else if (sourceClass.sourceClassID==2)
+    {
+        if(exististingConnection)
+            mConnectSf=SFC_RAMP_DOWN;
+        else
+            mConnectSf=SFC_CONNECT;
+
+        mStateflow=SF_NAVI;
+    }
+    else if (sourceClass.sourceClassID==3)
+    {
+        if(exististingConnection)
+            mConnectSf=SFC_RAMP_DOWN;
+        else
+            mConnectSf=SFC_CONNECT;
+
+        mStateflow=SF_TA;
+    }
+
+    callStateFlowHandler();
+    return (E_OK);
 }
 
 am_Error_e CAmControlSenderBase::hookUserDisconnectionRequest(const am_mainConnectionID_t connectionID)
 {
-    //first check if there is a connectionID like that
-    am_MainConnection_s mainConnection;
-    am_Error_e error;
-    if ((error = mControlReceiveInterface->getMainConnectionInfoDB(connectionID, mainConnection)) != E_OK)
+    if (mStateflow==SF_NAVI)
     {
-        return error;
+        mNaviSf=NAVC_RAMP_DOWN_AGAIN;
+        callStateFlowHandler();
+        return (E_OK);
     }
-
-    std::vector<am_connectionID_t>::iterator it(mainConnection.listConnectionID.begin());
-    std::vector<handleStatus> listHandleStaus;
-    for (; it != mainConnection.listConnectionID.end(); ++it)
+    if (mStateflow==SF_TA)
     {
-        handleStatus status;
-        status.status = false;
-        if((error=mControlReceiveInterface->disconnect(status.handle, *it)))
-        {
-            logError("Could not disconnect, Error", error);
-        }
-        listHandleStaus.push_back(status);
+        mTrafficSf=TA_RAMP_DOWN_AGAIN;
+        callStateFlowHandler();
+        return (E_OK);
     }
-    mainConnectionSet set;
-    set.connectionID = connectionID;
-    set.listHandleStaus = listHandleStaus;
-    mListOpenDisconnections.push_back(set);
-    return E_OK;
+    else  if (mStateflow!=SF_NONE)
+    {
+        return (E_NOT_POSSIBLE);
+    }
+    disconnect(connectionID);
+    return (E_OK);
 }
 
 am_Error_e CAmControlSenderBase::hookUserSetMainSinkSoundProperty(const am_sinkID_t sinkID, const am_MainSoundProperty_s & soundProperty)
 {
+    if (mStateflow!=SF_NONE)
+        return (E_NOT_POSSIBLE);
+
     if (sinkID == 0)
-        return E_NON_EXISTENT;
+        return (E_NON_EXISTENT);
 
     mainSinkSoundPropertySet set;
     set.sinkID = sinkID;
     set.mainSoundProperty = soundProperty;
     am_SoundProperty_s sp;
-    //I know this is bad - just for the reference, ok?
+    std::vector<mainSinkSoundPropertySet>::iterator it(mListMainSoundPropertyChanges.begin());
+    for (; it != mListMainSoundPropertyChanges.end(); ++it)
+    {
+        if (it->sinkID == sinkID)
+            return E_NOT_POSSIBLE;
+    }
+
+//I know this is bad - just for the reference, ok?
     sp.type = static_cast<am_SoundPropertyType_e>(soundProperty.type);
-    sp.value = soundProperty.value;
+    sp.value = (soundProperty.value - 5) * 30;
     am_Error_e error;
     if ((error = mControlReceiveInterface->setSinkSoundProperty(set.handle, sinkID, sp)) != E_OK)
     {
@@ -171,6 +223,9 @@ am_Error_e CAmControlSenderBase::hookUserSetSystemProperty(const am_SystemProper
 
 am_Error_e CAmControlSenderBase::hookUserVolumeChange(const am_sinkID_t SinkID, const am_mainVolume_t newVolume)
 {
+    if (mStateflow!=SF_NONE)
+        return (E_NOT_POSSIBLE);
+
     assert(SinkID!=0);
     mainVolumeSet set;
     set.sinkID = SinkID;
@@ -178,19 +233,19 @@ am_Error_e CAmControlSenderBase::hookUserVolumeChange(const am_sinkID_t SinkID,
     am_Error_e error;
 
     std::vector<mainVolumeSet>::iterator it(mListOpenVolumeChanges.begin());
-    for(;it!=mListOpenVolumeChanges.end();++it)
+    for (; it != mListOpenVolumeChanges.end(); ++it)
     {
-        if (it->sinkID==SinkID)
+        if (it->sinkID == SinkID)
             return E_NOT_POSSIBLE;
     }
 
     am_Sink_s sinkData;
-    mControlReceiveInterface->getSinkInfoDB(SinkID,sinkData);
+    mControlReceiveInterface->getSinkInfoDB(SinkID, sinkData);
 
-    if (sinkData.mainVolume==newVolume)
+    if (sinkData.mainVolume == newVolume)
         return E_NO_CHANGE;
 
-    if ((error = mControlReceiveInterface->setSinkVolume(set.handle, SinkID, newVolume*3199, RAMP_UNKNOWN, 20)) != E_OK)
+    if ((error = mControlReceiveInterface->setSinkVolume(set.handle, SinkID, (newVolume-10)*6, RAMP_UNKNOWN, 20)) != E_OK)
     {
         return error;
     }
@@ -200,20 +255,23 @@ am_Error_e CAmControlSenderBase::hookUserVolumeChange(const am_sinkID_t SinkID,
 
 am_Error_e CAmControlSenderBase::hookUserVolumeStep(const am_sinkID_t SinkID, const int16_t increment)
 {
+    if (mStateflow!=SF_NONE)
+        return (E_NOT_POSSIBLE);
+
     assert(SinkID!=0);
     mainVolumeSet set;
     set.sinkID = SinkID;
     am_Error_e error;
     am_Sink_s sink;
     std::vector<mainVolumeSet>::iterator it(mListOpenVolumeChanges.begin());
-    for(;it!=mListOpenVolumeChanges.end();++it)
+    for (; it != mListOpenVolumeChanges.end(); ++it)
     {
-        if (it->sinkID==SinkID)
+        if (it->sinkID == SinkID)
             return E_NOT_POSSIBLE;
     }
     mControlReceiveInterface->getSinkInfoDB(SinkID, sink);
-    set.mainVolume = sink.volume + increment*3199;
-    if ((error = mControlReceiveInterface->setSinkVolume(set.handle, SinkID, set.mainVolume, RAMP_UNKNOWN, 20)) != E_OK)
+    set.mainVolume = sink.mainVolume + increment;
+    if ((error = mControlReceiveInterface->setSinkVolume(set.handle, SinkID, (set.mainVolume-10)*6, RAMP_UNKNOWN, 20)) != E_OK)
     {
         return error;
     }
@@ -223,6 +281,9 @@ am_Error_e CAmControlSenderBase::hookUserVolumeStep(const am_sinkID_t SinkID, co
 
 am_Error_e CAmControlSenderBase::hookUserSetSinkMuteState(const am_sinkID_t sinkID, const am_MuteState_e muteState)
 {
+    if (mStateflow!=SF_NONE)
+        return (E_NOT_POSSIBLE);
+
     assert(sinkID!=0);
 
     mainVolumeSet set;
@@ -241,26 +302,26 @@ am_Error_e CAmControlSenderBase::hookUserSetSinkMuteState(const am_sinkID_t sink
     }
     else
     {
-        set.mainVolume=sink.mainVolume;
+        set.mainVolume = sink.mainVolume;
         if ((error = mControlReceiveInterface->setSinkVolume(set.handle, sinkID, set.mainVolume, RAMP_GENIVI_DIRECT, 20)) != E_OK)
         {
             return error;
         }
     }
     mListOpenVolumeChanges.push_back(set);
-    mControlReceiveInterface->changeSinkMuteStateDB(muteState,sinkID);
+    mControlReceiveInterface->changeSinkMuteStateDB(muteState, sinkID);
     return (E_OK);
 }
 
 am_Error_e CAmControlSenderBase::hookSystemRegisterDomain(const am_Domain_s & domainData, am_domainID_t & domainID)
 {
-    //this application does not do anything with it -> but some product might want to take influence here
+//this application does not do anything with it -> but some product might want to take influence here
     return mControlReceiveInterface->enterDomainDB(domainData, domainID);
 }
 
 am_Error_e CAmControlSenderBase::hookSystemDeregisterDomain(const am_domainID_t domainID)
 {
-    //this application does not do anything with it -> but some product might want to take influence here
+//this application does not do anything with it -> but some product might want to take influence here
     return mControlReceiveInterface->removeDomainDB(domainID);
 }
 
@@ -271,49 +332,49 @@ void CAmControlSenderBase::hookSystemDomainRegistrationComplete(const am_domainI
 
 am_Error_e CAmControlSenderBase::hookSystemRegisterSink(const am_Sink_s & sinkData, am_sinkID_t & sinkID)
 {
-    //this application does not do anything with it -> but some product might want to take influence here
+//this application does not do anything with it -> but some product might want to take influence here
     return mControlReceiveInterface->enterSinkDB(sinkData, sinkID);
 }
 
 am_Error_e CAmControlSenderBase::hookSystemDeregisterSink(const am_sinkID_t sinkID)
 {
-    //this application does not do anything with it -> but some product might want to take influence here
+//this application does not do anything with it -> but some product might want to take influence here
     return mControlReceiveInterface->removeSinkDB(sinkID);
 }
 
 am_Error_e CAmControlSenderBase::hookSystemRegisterSource(const am_Source_s & sourceData, am_sourceID_t & sourceID)
 {
-    //this application does not do anything with it -> but some product might want to take influence here
+//this application does not do anything with it -> but some product might want to take influence here
     return mControlReceiveInterface->enterSourceDB(sourceData, sourceID);
 }
 
 am_Error_e CAmControlSenderBase::hookSystemDeregisterSource(const am_sourceID_t sourceID)
 {
-    //this application does not do anything with it -> but some product might want to take influence here
+//this application does not do anything with it -> but some product might want to take influence here
     return mControlReceiveInterface->removeSourceDB(sourceID);
 }
 
 am_Error_e CAmControlSenderBase::hookSystemRegisterGateway(const am_Gateway_s & gatewayData, am_gatewayID_t & gatewayID)
 {
-    //this application does not do anything with it -> but some product might want to take influence here
+//this application does not do anything with it -> but some product might want to take influence here
     return mControlReceiveInterface->enterGatewayDB(gatewayData, gatewayID);
 }
 
 am_Error_e CAmControlSenderBase::hookSystemDeregisterGateway(const am_gatewayID_t gatewayID)
 {
-    //this application does not do anything with it -> but some product might want to take influence here
+//this application does not do anything with it -> but some product might want to take influence here
     return mControlReceiveInterface->removeGatewayDB(gatewayID);
 }
 
 am_Error_e CAmControlSenderBase::hookSystemRegisterCrossfader(const am_Crossfader_s & crossfaderData, am_crossfaderID_t & crossfaderID)
 {
-    //this application does not do anything with it -> but some product might want to take influence here
+//this application does not do anything with it -> but some product might want to take influence here
     return mControlReceiveInterface->enterCrossfaderDB(crossfaderData, crossfaderID);
 }
 
 am_Error_e CAmControlSenderBase::hookSystemDeregisterCrossfader(const am_crossfaderID_t crossfaderID)
 {
-    //this application does not do anything with it -> but some product might want to take influence here
+//this application does not do anything with it -> but some product might want to take influence here
     return mControlReceiveInterface->removeCrossfaderDB(crossfaderID);
 }
 
@@ -374,7 +435,7 @@ void CAmControlSenderBase::hookSystemTimingInformationChanged(const am_mainConne
 void CAmControlSenderBase::cbAckConnect(const am_Handle_s handle, const am_Error_e errorID)
 {
     (void) errorID;
-    //\todo:error checking
+//\todo:error checking
     std::vector<mainConnectionSet>::iterator it(mListOpenConnections.begin());
     for (; it != mListOpenConnections.end(); ++it)
     {
@@ -393,12 +454,13 @@ void CAmControlSenderBase::cbAckConnect(const am_Handle_s handle, const am_Error
             break;
         }
     }
+    callStateFlowHandler();
 }
 
 void CAmControlSenderBase::cbAckDisconnect(const am_Handle_s handle, const am_Error_e errorID)
 {
     (void) errorID;
-    //\todo:error checking
+//\todo:error checking
     std::vector<mainConnectionSet>::iterator it(mListOpenDisconnections.begin());
     for (; it != mListOpenDisconnections.end(); ++it)
     {
@@ -417,6 +479,7 @@ void CAmControlSenderBase::cbAckDisconnect(const am_Handle_s handle, const am_Er
             break;
         }
     }
+    callStateFlowHandler();
 }
 
 void CAmControlSenderBase::cbAckCrossFade(const am_Handle_s handle, const am_HotSink_e hostsink, const am_Error_e error)
@@ -441,6 +504,7 @@ void CAmControlSenderBase::cbAckSetSinkVolumeChange(const am_Handle_s handle, co
             break;
         }
     }
+    callStateFlowHandler();
 }
 
 void CAmControlSenderBase::cbAckSetSourceVolumeChange(const am_Handle_s handle, const am_volume_t voulme, const am_Error_e error)
@@ -448,12 +512,14 @@ void CAmControlSenderBase::cbAckSetSourceVolumeChange(const am_Handle_s handle,
     (void) error;
     (void) voulme;
     (void) handle;
+    callStateFlowHandler();
 }
 
 void CAmControlSenderBase::cbAckSetSourceState(const am_Handle_s handle, const am_Error_e error)
 {
     (void) error;
     (void) handle;
+    callStateFlowHandler();
 }
 
 void CAmControlSenderBase::cbAckSetSourceSoundProperty(const am_Handle_s handle, const am_Error_e error)
@@ -465,13 +531,15 @@ void CAmControlSenderBase::cbAckSetSourceSoundProperty(const am_Handle_s handle,
 void CAmControlSenderBase::cbAckSetSinkSoundProperty(const am_Handle_s handle, const am_Error_e error)
 {
     (void) error;
-    //\todo:error checking
+//\todo:error checking
     std::vector<mainSinkSoundPropertySet>::iterator it(mListMainSoundPropertyChanges.begin());
     for (; it != mListMainSoundPropertyChanges.end(); ++it)
     {
         if (handle.handle == it->handle.handle)
         {
             mControlReceiveInterface->changeMainSinkSoundPropertyDB(it->mainSoundProperty, it->sinkID);
+            mListMainSoundPropertyChanges.erase(it);
+            break;
         }
     }
 }
@@ -497,7 +565,7 @@ am_Error_e CAmControlSenderBase::getConnectionFormatChoice(const am_sourceID_t s
     (void) sourceID;
     (void) sinkID;
     (void) listRoute;
-    //ok, this is cheap. In a real product you have your preferences, right?
+//ok, this is cheap. In a real product you have your preferences, right?
     listPrioConnectionFormats = listPossibleConnectionFormats;
     return (E_OK);
 }
@@ -517,13 +585,242 @@ void CAmControlSenderBase::confirmRoutingReady()
     logInfo("ControlSenderPlugin got Command Ready confirmed");
 }
 
+void CAmControlSenderBase::confirmRoutingRundown()
+{
+    logInfo("ControlSenderPlugin got Command Rundown confirmed");
+}
+
+void CAmControlSenderBase::disconnect(am_mainConnectionID_t connectionID)
+{
+
+    am_MainConnection_s mainConnection;
+    am_Error_e error;
+    if ((error = mControlReceiveInterface->getMainConnectionInfoDB(connectionID, mainConnection)) != E_OK)
+    {
+        logError("CAmControlSenderBase::disconnect Could not getInfor for mainconnection Error: ", error);
+        return;
+    }
+
+    std::vector<am_connectionID_t>::iterator it(mainConnection.listConnectionID.begin());
+    std::vector<handleStatus> listHandleStaus;
+    for (; it != mainConnection.listConnectionID.end(); ++it)
+    {
+        handleStatus status;
+        status.status = false;
+        if ((error = mControlReceiveInterface->disconnect(status.handle, *it)))
+        {
+            logError("Could not disconnect, Error", error);
+        }
+        listHandleStaus.push_back(status);
+    }
+    mainConnectionSet set;
+    set.connectionID = connectionID;
+    set.listHandleStaus = listHandleStaus;
+    mListOpenDisconnections.push_back(set);
+}
+
 void CAmControlSenderBase::confirmCommandRundown()
 {
     logInfo("ControlSenderPlugin got Routing Rundown confirmed");
 }
 
-void CAmControlSenderBase::confirmRoutingRundown()
+void CAmControlSenderBase::connect(am_sourceID_t sourceID, am_sinkID_t sinkID, am_mainConnectionID_t mainConnectionID)
 {
-    logInfo("ControlSenderPlugin got Command Rundown confirmed");
+    std::vector<am_Route_s> listRoutes;
+    std::vector<am_connectionID_t> listConnectionIDs;
+    am_SourceClass_s sourceClass, tempSourceClass;
+    am_Handle_s handle;
+    mControlReceiveInterface->getRoute(false, sourceID, sinkID, listRoutes);
+    if (listRoutes.empty())
+        logError("CAmControlSenderBase::connect not possible");
+
+    std::vector<handleStatus> listHandleStaus;
+    std::vector<am_RoutingElement_s>::iterator it(listRoutes[0].route.begin());
+    for (; it != listRoutes[0].route.end(); ++it)
+    {
+        am_connectionID_t connectionID;
+        mControlReceiveInterface->connect(handle, connectionID, it->connectionFormat, it->sourceID, it->sinkID);
+        handleStatus status;
+        status.handle = handle;
+        status.status = false;
+        listHandleStaus.push_back(status);
+        listConnectionIDs.push_back(connectionID);
+    }
+    mainConnectionSet set;
+    set.connectionID = mainConnectionID;
+    set.listHandleStaus = listHandleStaus;
+    mControlReceiveInterface->changeMainConnectionRouteDB(mainConnectionID,listConnectionIDs);
+    mListOpenConnections.push_back(set);
 }
 
+void CAmControlSenderBase::callStateFlowHandler()
+{
+    logInfo("CAmControlSenderBase::callStateFlowHandler() called, state ",mStateflow);
+
+    switch(mStateflow)
+    {
+    case SF_CONNECT:
+        callConnectHandler();
+        break;
+    case SF_TA:
+        callTAHandler();
+        break;
+    case SF_NAVI:
+        callNaviHandler();
+        break;
+    default:
+        break;
+
+    }
+}
+
+void CAmControlSenderBase::callConnectHandler()
+{
+    logInfo("CAmControlSenderBase::callConnectHandler() called, state ",mConnectSf);
+
+    am_Handle_s handle;
+    am_Sink_s sinkData;
+    switch (mConnectSf)
+    {
+    case SFC_RAMP_DOWN:
+        mControlReceiveInterface->setSinkVolume(handle, mConnectData.sinkID, -60, RAMP_GENIVI_EXP_INV, 4000);
+        mConnectSf = SFC_SOURCE_STATE_OFF;
+        break;
+    case SFC_SOURCE_STATE_OFF:
+        mControlReceiveInterface->setSourceState(handle, mConnectData.oldSourceID, SS_OFF);
+        mConnectSf = SFC_DISCONNECT;
+        break;
+    case SFC_DISCONNECT:
+        disconnect(mConnectData.currentMainConnection);
+        mConnectSf = SFC_CONNECT;
+        break;
+    case SFC_CONNECT:
+        connect(mConnectData.sourceID, mConnectData.sinkID, mConnectData.newMainConnection);
+        mConnectSf = SFC_SOURCE_STATE_ON;
+        break;
+    case SFC_SOURCE_STATE_ON:
+        mControlReceiveInterface->setSourceState(handle, mConnectData.sourceID, SS_ON);
+        mConnectSf = SFC_RAMP_UP;
+        break;
+    case SFC_RAMP_UP:
+        mControlReceiveInterface->getSinkInfoDB(mConnectData.sinkID, sinkData);
+        if (mControlReceiveInterface->setSinkVolume(handle, mConnectData.sinkID, (sinkData.mainVolume-10)*6, RAMP_GENIVI_EXP_INV, 4000)==E_NO_CHANGE)
+            mStateflow=SF_NONE;
+        mConnectSf=SFC_FINISHED;
+        break;
+    case SFC_FINISHED:
+        mStateflow=SF_NONE;
+        break;
+    default:
+        break;
+    }
+}
+
+void CAmControlSenderBase::callNaviHandler()
+{
+    logInfo("CAmControlSenderBase::callNaviHandler() called, state ",mConnectSf);
+
+       am_Handle_s handle;
+       am_Source_s sourceData;
+       am_Sink_s sinkData;
+       switch (mNaviSf)
+       {
+       case NAVC_RAMP_DOWN:
+           mControlReceiveInterface->setSourceVolume(handle, mConnectData.oldSourceID, -13, RAMP_UNKNOWN, 2000);
+           mNaviSf = NAVC_CONNECT;
+           break;
+       case NAVC_CONNECT:
+           connect(mConnectData.sourceID, mConnectData.sinkID, mConnectData.newMainConnection);
+           mNaviSf = NAVC_SOURCE_STATE_ON;
+           break;
+       case NAVC_SOURCE_STATE_ON:
+           mControlReceiveInterface->setSourceState(handle, mConnectData.sourceID, SS_ON);
+           mNaviSf = NAVC_RAMP_UP;
+           break;
+       case NAVC_RAMP_UP:
+           mControlReceiveInterface->getSinkInfoDB(mConnectData.sinkID, sinkData);
+           mControlReceiveInterface->setSinkVolume(handle, mConnectData.sinkID, (sinkData.mainVolume-10)*60+2, RAMP_UNKNOWN, 2000);
+           mNaviSf=NAVC_WAIT_STATE;
+           break;
+       case NAVC_WAIT_STATE:
+           mNaviSf=NAVC_RAMP_DOWN_AGAIN;
+           break;
+       case NAVC_RAMP_DOWN_AGAIN:
+           mControlReceiveInterface->setSinkVolume(handle, mConnectData.sinkID, (sinkData.mainVolume-10)*60, RAMP_UNKNOWN, 2000);
+           mNaviSf=NAVC_SOURCE_VOLUME_BACK;
+           break;
+       case NAVC_SOURCE_VOLUME_BACK:
+           mControlReceiveInterface->setSourceVolume(handle, mConnectData.oldSourceID, 0, RAMP_UNKNOWN, 2000);
+           mNaviSf=NAVC_SOURCE_ACTIVITY_BACK;
+           break;
+       case NAVC_SOURCE_ACTIVITY_BACK:
+           mControlReceiveInterface->setSourceState(handle, mConnectData.sourceID, SS_OFF);
+           mNaviSf=NAVC_DISCONNECT;
+           break;
+       case NAVC_DISCONNECT:
+           disconnect(mConnectData.newMainConnection);
+           mNaviSf=NAVC_FINISHED;
+           break;
+       case NAVC_FINISHED:
+           mStateflow=SF_NONE;
+           break;
+       default:
+           break;
+       }
+}
+
+void CAmControlSenderBase::callTAHandler()
+{
+    logInfo("CAmControlSenderBase::callTAHandler() called, state ",mConnectSf);
+
+       am_Handle_s handle;
+       am_Source_s sourceData;
+       am_Sink_s sinkData;
+       switch (mTrafficSf)
+       {
+       case TA_RAMP_DOWN:
+           mControlReceiveInterface->setSourceState(handle, mConnectData.oldSourceID, SS_PAUSED);
+           mTrafficSf = TA_CONNECT;
+           break;
+       case TA_CONNECT:
+           connect(mConnectData.sourceID, mConnectData.sinkID, mConnectData.newMainConnection);
+           mTrafficSf = TA_SOURCE_STATE_ON;
+           break;
+       case TA_SOURCE_STATE_ON:
+           mControlReceiveInterface->setSourceState(handle, mConnectData.sourceID, SS_ON);
+           mTrafficSf = TA_RAMP_UP;
+           break;
+       case TA_RAMP_UP:
+           mControlReceiveInterface->getSinkInfoDB(mConnectData.sinkID, sinkData);
+           mControlReceiveInterface->setSinkVolume(handle, mConnectData.sinkID, (sinkData.mainVolume-10)*60+2, RAMP_UNKNOWN, 2000);
+           mTrafficSf=TA_WAIT_STATE;
+           break;
+       case TA_WAIT_STATE:
+           mTrafficSf=TA_RAMP_DOWN_AGAIN;
+           break;
+       case TA_RAMP_DOWN_AGAIN:
+           mControlReceiveInterface->setSinkVolume(handle, mConnectData.sinkID, (sinkData.mainVolume-10)*60, RAMP_UNKNOWN, 2000);
+           mTrafficSf=TA_SOURCE_STATE_OFF;
+           break;
+       case TA_SOURCE_STATE_OFF:
+           mControlReceiveInterface->setSourceState(handle, mConnectData.oldSourceID, SS_ON);
+           mTrafficSf=TA_SOURCE_STATE_OLD_OFF;
+           break;
+       case TA_SOURCE_STATE_OLD_OFF:
+           mControlReceiveInterface->setSourceState(handle, mConnectData.sourceID, SS_OFF);
+           mTrafficSf=TA_DISCONNECT;
+           break;
+       case TA_DISCONNECT:
+           disconnect(mConnectData.newMainConnection);
+           mTrafficSf=TA_FINISHED;
+           break;
+       case TA_FINISHED:
+           mStateflow=SF_NONE;
+           break;
+       default:
+           break;
+       }
+}
+
+
+