cnfconference.cpp

Conferencing code using Dialogic hardware

/**********@@@SOFT@@@WARE@@@COPY@@@RIGHT@@@**********************************
* DIALOGIC CONFIDENTIAL
*
* Copyright (C) 2006-2007 Dialogic Corporation. All Rights Reserved.
* The source code contained or described herein and all documents related
* to the source code ("Material") are owned by Dialogic Corporation or its
* suppliers or licensors. Title to the Material remains with Dialogic Corporation
* or its suppliers and licensors. The Material contains trade secrets and
* proprietary and confidential information of Dialogic or its suppliers and
* licensors. The Material is protected by worldwide copyright and trade secret
* laws and treaty provisions. No part of the Material may be used, copied,
* reproduced, modified, published, uploaded, posted, transmitted, distributed,
* or disclosed in any way without Dialogic's prior express written permission.
*
* No license under any patent, copyright, trade secret or other intellectual
* property right is granted to or conferred upon you by disclosure or delivery
* of the Materials, either expressly, by implication, inducement, estoppel or
* otherwise. Any license under such intellectual property rights must be
* express and approved by Dialogic in writing.
*
***********************************@@@SOFT@@@WARE@@@COPY@@@RIGHT@@@**********/
//***********************************************************************
//***********************************************************************
#include "pdl.h"

// Conference.cpp: implementation of the CConference class.
//
//////////////////////////////////////////////////////////////////////


//
// State machine - specific states
//
enum {
   S_SETATTR,              // Device Open
   S_SETATTR_EXIT,         // Exit while opening

   S_ENABLEEVENTS,         // Enable Events
   S_ENABLEEVENTS_EXIT,    // Exit while enable events in progress

// Conference
   S_OPEN_DX_PARTY,        // ...cnf_PartyOpen  
   S_OPEN_DX_PARTY_EXIT,   // ...cnf_PartyOpen  exiting
   S_ADD_DX_PARTY,         // ...cnf_addParty
   S_ADD_DX_PARTY_EXIT,    // ...cnf_addParty exiting
   S_DEVCONNECT1,          // ...dev_Connect ( first event)
   S_DEVCONNECT2,          // ...dev_Connect ( second event)

   S_DEVCONNECT1_EXIT,     // ...dev_Connect ( first event) exit
   S_DEVCONNECT2_EXIT,     // ...dev_Connect ( second event) exit
   S_DEVCONNECT_EXIT,      // ...dev_Connect exiting
   
   S_REMOVE_DX_PARTY,      // ... remove party 
   S_DEVDISCONNECTDX,      // ... DevDisconect(voice)
   S_DEVDISCONNECTCNF,     // ... DevDisconnect (cnf party)
   S_BEEP,                 //  ... Beep 
   S_BEEP_EXIT,            // ... Exit while beeping 
   S_BEEP_BYE,             // ... Beep before disbanding conference 
};

static NAME_TABLE state_tbl[] ={
    {"S_SETATTR",           S_SETATTR            },
    {"S_SETATTR_EXIT",      S_SETATTR_EXIT       },

    {"S_ENABLEEVENTS",      S_ENABLEEVENTS       },
    {"S_ENABLEEVENTS_EXIT", S_ENABLEEVENTS_EXIT  },

    {"S_OPEN_DX_PARTY",     S_OPEN_DX_PARTY      },
    {"S_ADD_DX_PARTY",      S_ADD_DX_PARTY       },

    {"S_DEVCONNECT1",       S_DEVCONNECT1        },
    {"S_DEVCONNECT2",       S_DEVCONNECT2        },

    {"S_OPEN_DX_PARTY_EXIT",S_OPEN_DX_PARTY_EXIT },
    {"S_ADD_DX_PARTY_EXIT", S_ADD_DX_PARTY_EXIT  },
    {"S_DEVCONNECT1_EXIT",  S_DEVCONNECT1_EXIT   },
    {"S_DEVCONNECT2_EXIT",  S_DEVCONNECT2_EXIT   },


    {"S_REMOVE_DX_PARTY",   S_REMOVE_DX_PARTY    },
    {"S_DEVDISCONNECTDX",   S_DEVDISCONNECTDX    },
    {"S_DEVDISCONNECTCNF",  S_DEVDISCONNECTCNF   },

    {"S_BEEP",              S_BEEP   },
    {"S_BEEP_EXIT",         S_BEEP_EXIT   },
    {"S_BEEP_BYE",          S_BEEP_BYE   },
    
    {0, 0}
};  // End of state_tbl[]

//*****************************************************************************
// Purpose	: 
//    return state name for given value
// Parameters:	
//    [in] state
// Returns:	
//    name 
//*****************************************************************************
const char * CnfConference::state_name(int state){
const char *name;
   if (! str_findname(state,&name,state_tbl) ){
         name = common_state_name(state);
   }
 return name;
} // End of state_name()


enum {
    A_SETATTR,               // set parameters 
    A_ENABLEEVENTS,          // Enable events
    A_TRYCLOSE,              // Close if there are no parties in this conference

    A_OPEN_DX_PARTY,         // cnf_OpenParty (voice)
    A_ADD_DX_PARTY,          // cnf_AddParty 
    A_DEVCONNECT,            // dev_Connect 
    A_MOVE,                  // do nothing, Advance to next state
    A_MOVE_DEVCONNECT2_EXIT, // do nothing, Advance to s_devdisconnect2_exit

    A_DEVDISCONNECTDX,       // dev_DisConnect 
    A_DEVDISCONNECTCNF,      // dev_DisConnect 
    A_REMOVE_DX_PARTY,       // cnf_RemoveParty 
    A_CLOSE_DX_PARTY,        // cnf_CloseParty 
    A_BEEP_IN,               // beep in
    A_BEEP_OUT,              // beep out
    A_BEEP_BYE,              // beep out
    A_DISBAND                // Disband
};

static NAME_TABLE ac_tbl[] = {
    { "A_SETATTR",                A_SETATTR           }, 
    { "A_ENABLEEVENTS",           A_ENABLEEVENTS      }, 
    { "A_TRYCLOSE",               A_TRYCLOSE          }, 

    { "A_OPEN_DX_PARTY",          A_OPEN_DX_PARTY     }, 
    { "A_ADD_DX_PARTY",           A_ADD_DX_PARTY      }, 
    { "A_DEVCONNECT",             A_DEVCONNECT        },    
    { "A_MOVE",                   A_MOVE              },    
    { "A_MOVE_DEVCONNECT2_EXIT",  A_MOVE_DEVCONNECT2_EXIT   },    

    { "A_DEVDISCONNECTDX",        A_DEVDISCONNECTDX   }, 
    { "A_DEVDISCONNECTCNF",       A_DEVDISCONNECTCNF  }, 
    { "A_REMOVE_DX_PARTY",        A_REMOVE_DX_PARTY   }, 
    { "A_CLOSE_DX_PARTY",         A_CLOSE_DX_PARTY    }, 

    { "A_BEEP_IN",                A_BEEP_IN    }, 
    { "A_BEEP_OUT",               A_BEEP_OUT    }, 
    { "A_BEEP_BYE",               A_BEEP_BYE    }, 
    { "A_DISBAND",                A_DISBAND    }, 


    { 0,0 }     
};  // End of ac_tbl[]

//*****************************************************************************
// Purpose	: 
//    return action name for given value
// Parameters:	
//    [in] action
// Returns:	
//    name 
//*****************************************************************************
const char * CnfConference::action_name(int action){
 const char *name;
  if (! str_findname(action, &name, ac_tbl) ){
        name = common_action_name(action);
  }
  return name;
} // End of action_name()

//===========================================================
// OPEN ->  SET_ATTR -> RELAX
// S_OPEN ->S_SETATTR-> S_ADDVOCIE -> S_RELAX
static ACTION_STRU cnf_action_stru[] = {
//  current_state     action          state_if_pass   action_if_fail
    { S_ANY,          A_CLOSE,        S_FINAL,          A_GIVEUP   },
    { S_ANY,          A_GIVEUP,       S_FINAL,          A_NONE     },
    
    { S_ANY,          A_CLOSE_DX_PARTY,   S_WAIT_SUBDEV,        A_TRYCLOSE },
    { S_ANY,          A_REMOVE_DX_PARTY,  S_REMOVE_DX_PARTY,    A_CLOSE_DX_PARTY  },

    { S_ANY,          A_DEVDISCONNECTDX,   S_DEVDISCONNECTDX,   A_DEVDISCONNECTCNF},
    { S_ANY,          A_DEVDISCONNECTCNF,  S_DEVDISCONNECTCNF,  A_REMOVE_DX_PARTY },
    { S_ANY,          A_TRYCLOSE,          S_WAIT_SUBDEV,       A_NONE },



    { S_OPEN,         A_SETATTR,      S_SETATTR,        A_CLOSE    },
    { S_OPEN,         A_EXIT,         S_OPEN_EXIT,      A_CLOSE    },


    { S_SETATTR,      A_ENABLEEVENTS, S_ENABLEEVENTS,   A_CLOSE    },
    { S_SETATTR,      A_EXIT,         S_SETATTR_EXIT,   A_CLOSE    },

    
    { S_ENABLEEVENTS, A_OPEN_DX_PARTY,S_OPEN_DX_PARTY,     A_CLOSE },
    { S_ENABLEEVENTS, A_EXIT,         S_ENABLEEVENTS_EXIT, A_CLOSE },


//Conference
    { S_OPEN_DX_PARTY,  A_EXIT,           S_OPEN_DX_PARTY_EXIT, A_NONE           },
    { S_OPEN_DX_PARTY,  A_ADD_DX_PARTY,   S_ADD_DX_PARTY,       A_CLOSE_DX_PARTY },
    { S_OPEN_DX_PARTY,  A_RELAX,          S_RELAX,              A_NONE },

    { S_OPEN_DX_PARTY,  A_DEVCONNECT,     S_DEVCONNECT1,        A_CLOSE_DX_PARTY },

// Add party
    { S_ADD_DX_PARTY,       A_EXIT,          S_ADD_DX_PARTY_EXIT,   A_NONE        },
    { S_ADD_DX_PARTY,       A_DEVCONNECT,    S_DEVCONNECT1,         A_REMOVE_DX_PARTY },

    { S_ADD_DX_PARTY,       A_RELAX,         S_RELAX,           A_NONE },

    { S_ADD_DX_PARTY,       A_CLOSE_DX_PARTY,  S_WAIT_SUBDEV,      A_TRYCLOSE  },

// Dev connect
    { S_DEVCONNECT1,    A_EXIT,           S_DEVCONNECT1_EXIT,         A_NONE },
    { S_DEVCONNECT1,    A_MOVE,           S_DEVCONNECT2,              A_NONE  },
    { S_DEVCONNECT1,    A_MOVE_DEVCONNECT2_EXIT, S_DEVCONNECT2_EXIT,  A_NONE  },

    { S_DEVCONNECT1_EXIT,A_MOVE,          S_DEVCONNECT2_EXIT,         A_NONE  },


    { S_DEVCONNECT2,    A_EXIT,            S_DEVCONNECT2_EXIT,         A_NONE },
    { S_DEVCONNECT2,    A_DEVDISCONNECTDX, S_DEVDISCONNECTDX,          A_REMOVE_DX_PARTY  },
    { S_DEVCONNECT2,    A_RELAX,           S_RELAX,                    A_NONE  },
    { S_DEVCONNECT2,    A_ADD_DX_PARTY,    S_ADD_DX_PARTY,             A_CLOSE_DX_PARTY },

    { S_DEVCONNECT2,    A_REMOVE_DX_PARTY, S_REMOVE_DX_PARTY,          A_CLOSE_DX_PARTY },

    { S_DEVCONNECT2_EXIT, A_DEVDISCONNECTDX, S_DEVDISCONNECTDX,     A_REMOVE_DX_PARTY  },
    { S_DEVCONNECT2_EXIT, A_REMOVE_DX_PARTY, S_REMOVE_DX_PARTY,     A_CLOSE_DX_PARTY },


    { S_RELAX,           A_TRYCLOSE,     S_WAIT_SUBDEV,             A_NONE     },   


    { S_RELAX,           A_BEEP_OUT,    S_BEEP,         A_MOVE },   
    { S_RELAX,           A_BEEP_IN,     S_BEEP,         A_MOVE },   
    { S_RELAX,           A_BEEP_BYE,    S_BEEP_BYE,     A_DISBAND },

    { S_RELAX,           A_MOVE,        S_RELAX,        A_NONE },   

    { S_RELAX,           A_DISBAND,     S_RELAX,        A_NONE },   

    { S_BEEP,            A_EXIT,        S_BEEP_EXIT,    A_NONE },   
    { S_BEEP,            A_MOVE,        S_RELAX,        A_NONE },   

    { S_BEEP_BYE,        A_DISBAND,     S_RELAX,        A_NONE },
    { S_BEEP_BYE,        A_EXIT,        S_BEEP_EXIT,    A_NONE },

        
    { S_WAIT_SUBDEV,      A_TRYCLOSE,     S_WAIT_SUBDEV,    A_NONE     },   


// No operation
    { S_ANY,          A_NONE,         S_SAME,           A_NONE     },

// State machine error (missing case to handle specified action)
    { S_ANY,          A_ERROR,        S_SAME,           A_CLOSE    },

// Not part of state machine, indicates last line
    { S_END,   0,    0,     0  }   

};  // End of cnf_action_stru[]

//===========================================================
static EVENT_STRU cnf_event_stru[] = {

//  current_state     event                        action           

 // After Open        
    { S_OPEN,         CNFEV_OPEN_CONF,           A_SETATTR   },
    { S_OPEN,         CNFEV_OPEN_CONF_FAIL,      A_CLOSE     },
    { S_OPEN,         USREV_EXIT_REQUEST,        A_EXIT      },
    { S_OPEN,         USREV_TIMEOUT,             A_CLOSE     },
    
    { S_OPEN_EXIT,    CNFEV_OPEN,                A_CLOSE,    },
    { S_OPEN_EXIT,    CNFEV_OPEN_FAIL,           A_CLOSE,    },
    { S_OPEN_EXIT,    USREV_TIMEOUT,             A_CLOSE,    },

// After Set Attributes
    { S_SETATTR,      CNFEV_SET_ATTRIBUTE,       A_ENABLEEVENTS },
    { S_SETATTR,      CNFEV_SET_ATTRIBUTE_FAIL,  A_CLOSE     },
    { S_SETATTR,      USREV_EXIT_REQUEST,        A_EXIT      },
    { S_SETATTR,      USREV_TIMEOUT,             A_CLOSE     },

    { S_SETATTR_EXIT, CNFEV_SET_ATTRIBUTE,       A_CLOSE     },
    { S_SETATTR_EXIT, CNFEV_SET_ATTRIBUTE_FAIL,  A_CLOSE     },
    { S_SETATTR_EXIT, USREV_TIMEOUT,             A_CLOSE     },

// After enable events
    { S_ENABLEEVENTS,      CNFEV_ENABLE_EVENT,        A_OPEN_DX_PARTY },
    { S_ENABLEEVENTS,      CNFEV_ENABLE_EVENT_FAIL,   A_CLOSE     },
    { S_ENABLEEVENTS,      USREV_EXIT_REQUEST,        A_EXIT      },
    { S_ENABLEEVENTS,      USREV_TIMEOUT,             A_CLOSE     },

    { S_ENABLEEVENTS_EXIT, CNFEV_ENABLE_EVENT,        A_CLOSE     },
    { S_ENABLEEVENTS_EXIT, CNFEV_ENABLE_EVENT_FAIL,   A_CLOSE     },
    { S_ENABLEEVENTS_EXIT, USREV_TIMEOUT,             A_CLOSE     },


// Conference
// open party
    { S_OPEN_DX_PARTY,      USREV_EXIT_REQUEST,        A_EXIT        },
    { S_OPEN_DX_PARTY,      CNFEV_OPEN_PARTY_FAIL,     A_CLOSE_DX_PARTY  },
    { S_OPEN_DX_PARTY,      USREV_TIMEOUT,             A_CLOSE_DX_PARTY  },

 // case 2: first add
//  { S_OPEN_DX_PARTY,      CNFEV_OPEN_PARTY,          A_ADD_DX_PARTY    },
 // case 1: first devconnect
    { S_OPEN_DX_PARTY,      CNFEV_OPEN_PARTY,          A_DEVCONNECT    },
 
    { S_OPEN_DX_PARTY,      USREV_SKIP_VOICE,          A_RELAX       },

    { S_OPEN_DX_PARTY_EXIT, CNFEV_OPEN_PARTY_FAIL,     A_CLOSE_DX_PARTY  },
    { S_OPEN_DX_PARTY_EXIT, USREV_TIMEOUT,             A_CLOSE_DX_PARTY  },
    { S_OPEN_DX_PARTY_EXIT, CNFEV_OPEN_PARTY,          A_CLOSE_DX_PARTY  },


// Add party
    { S_ADD_DX_PARTY,       USREV_EXIT_REQUEST,        A_EXIT        },
    { S_ADD_DX_PARTY,       CNFEV_ADD_PARTY_FAIL,      A_CLOSE_DX_PARTY  },
    { S_ADD_DX_PARTY,       USREV_TIMEOUT,             A_CLOSE_DX_PARTY  },

// case 2: first add
//  { S_ADD_DX_PARTY,       CNFEV_ADD_PARTY,           A_DEVCONNECT  },
// case 1: first devconnect
    { S_ADD_DX_PARTY,       CNFEV_ADD_PARTY,           A_RELAX  },

    { S_ADD_DX_PARTY_EXIT,  CNFEV_ADD_PARTY_FAIL,      A_CLOSE_DX_PARTY  },
    { S_ADD_DX_PARTY_EXIT,  USREV_TIMEOUT,             A_CLOSE_DX_PARTY  },
    { S_ADD_DX_PARTY_EXIT,  CNFEV_ADD_PARTY,           A_REMOVE_DX_PARTY },

// Dev connect
    { S_DEVCONNECT1,    USREV_EXIT_REQUEST,        A_EXIT        },
    { S_DEVCONNECT1,    DMEV_CONNECT_FAIL,         A_MOVE_DEVCONNECT2_EXIT },
    { S_DEVCONNECT1,    USREV_TIMEOUT,             A_MOVE_DEVCONNECT2_EXIT },
    { S_DEVCONNECT1,    DMEV_CONNECT,              A_MOVE        },

    { S_DEVCONNECT1_EXIT, DMEV_CONNECT,            A_NONE        },
    { S_DEVCONNECT1_EXIT, DMEV_CONNECT_FAIL,       A_MOVE        },
    { S_DEVCONNECT1_EXIT, USREV_TIMEOUT,           A_MOVE        },

// Dev connect
    { S_DEVCONNECT2,    USREV_EXIT_REQUEST,        A_EXIT        },
    { S_DEVCONNECT2,    DMEV_CONNECT_FAIL,         A_DEVDISCONNECTDX },
    { S_DEVCONNECT2,    USREV_TIMEOUT,             A_DEVDISCONNECTDX },

// case 2: first add
//  { S_DEVCONNECT2,    DMEV_CONNECT,              A_RELAX       },
// case 1: first devconnect
    { S_DEVCONNECT2,    DMEV_CONNECT,              A_ADD_DX_PARTY           },

    { S_DEVCONNECT2_EXIT, DMEV_CONNECT,            A_DEVDISCONNECTDX        },
    { S_DEVCONNECT2_EXIT, DMEV_CONNECT_FAIL,       A_DEVDISCONNECTDX        },
    { S_DEVCONNECT2_EXIT, USREV_TIMEOUT,           A_DEVDISCONNECTDX        },

// Exit Request
    { S_RELAX,           USREV_EXIT_REQUEST,        A_DEVDISCONNECTDX },
    
// Beep in and out
    { S_RELAX,           USREV_BEEP_OUT,     A_BEEP_OUT    },