windows-nt-4.0/private/tapi/dev/apps/acd/acdtapi.c

///////////////////////////////////////////////////////////////////////////////////
//
//  ACDTAPI.C
//
//  This file handles all tapi functionality in the ACD sample
//
//
//
////////////////////////////////////////////////////////////////////////////////////
#include <windows.h>
#include <tapi.h>
#include "acdsmpl.h"

VOID CALLBACK LineCallback (DWORD hDevice,
                            DWORD dwMsg,
                            DWORD dwCallbackInstance, 
                            DWORD dwParam1,
                            DWORD dwParam2, 
                            DWORD dwParam3);


#define LogTapiError(__lResult__, __szString__)
#define LogError(__szString__)

extern ACDGLOBALS       g;


////////////////////////////////////////////////////////////////////////////////////
//
//  BOOL InitializeTapi()
//
//    Whatever is needed to init TAPI for the application.  This is called
//    before the main window is created.
//
////////////////////////////////////////////////////////////////////////////////////
BOOL InitializeTapi()
{
    DWORD                       dwAPIVersion;
    LINEINITIALIZEEXPARAMS      exparams;
    LONG                        lResult;
    DWORD                       i;
    LPLINEDEVCAPS               pLDC;


    // fill in lineinitex parameters
    exparams.dwTotalSize             = sizeof(LINEINITIALIZEEXPARAMS);
    exparams.dwOptions               = LINEINITIALIZEEXOPTION_USEHIDDENWINDOW;
    
    dwAPIVersion = TAPI_CURRENT_VERSION;

    // line init
    if ((lResult = lineInitializeEx(&g.hLineApp,
                                    g.hInstance,
                                    LineCallback,
                                    SZAPPNAME,
                                    &g.dwNumDevs,
                                    &dwAPIVersion,
                                    &exparams)) < 0)
    {
        LogTapiError(lResult, "lineInitializeEx");
        return FALSE;
    }

    // if there are no tapi devices, should probably
    // not continue
    if (g.dwNumDevs == 0)
    {
        LogError("No TAPI devices installed");
        lineShutdown(g.hLineApp);
        return FALSE;
    }

    // need to get the permanent device IDs to map from
    // an .ini file being read in
    g.pdwPermIDs = (LPDWORD)ACDAlloc(g.dwNumDevs * sizeof(DWORD));

    if (!g.pdwPermIDs)
    {
        return FALSE;
    }
    
    for (i = 0; i < g.dwNumDevs; i++)
    {
        pLDC = LineGetDevCaps(g.hLineApp,
                              i);

        if (pLDC)
        {
            g.pdwPermIDs[i] = pLDC->dwPermanentLineID;
            ACDFree(pLDC);
        }
    }

    return TRUE;
}


//////////////////////////////////////////////////////////////////////
//
//  BOOL CleanUp()
//
//  Called while shutting down.  free memory, close down tapi
//
//////////////////////////////////////////////////////////////////////
BOOL CleanUp()
{
    PAGENT      pAgent, pAgentNext;
    PGROUP      pGroup, pGroupNext;

    // remove agents
    pAgent = g.pAgents;
    while(pAgent)
    {
        pAgentNext = pAgent->pNext;
        DeleteAgent(pAgent);
        pAgent = pAgentNext;
    }

    // remove groups
    pGroup = g.pGroups;
    while (pGroup)
    {
        pGroupNext = pGroup->pNext;
        DeleteGroup(pGroup);
        pGroup = pGroupNext;
    }

    // free id array
    ACDFree(g.pdwPermIDs);

    // shutdown
    lineShutdown(g.hLineApp);

    return TRUE;
    
}
////////////////////////////////////////////////////////////////////////////////
//
//  LRESULT MakeGroupList(PAGENT pAgent,
//                        LPLINEAGENTGROUPLIST pGroupList)
//
//    Creates a LINEAGENTGROUPLIST for pAgent - group that the agent
//      is allowed to log into
//    Assumption:  don't care about address for group list
//
////////////////////////////////////////////////////////////////////////////////
LRESULT MakeGroupList(PAGENT pAgent,
                      LPLINEAGENTGROUPLIST pGroupList)
{
    PGROUP                  pGroup;
    DWORD                   dwTotalSizeNeeded, dwNameOffset, dwNumEntries;
    LPLINEAGENTGROUPENTRY   pEntry;
    LPTSTR                  pName;


    pGroup = g.pGroups;
    dwTotalSizeNeeded = sizeof(LINEAGENTGROUPLIST);
    pGroupList->dwNumEntries = 0;
    dwNumEntries = 0;

    // walk list of groups
    while (pGroup)
    {
        if (IsAgentInList(pGroup->pAgentList,
                          pAgent))
        // if found the agent, add the group to the group list
        {
            // incrememt number of entries
            dwNumEntries++;

            // add to total size needed
            dwTotalSizeNeeded += sizeof(LINEAGENTGROUPENTRY);
            dwTotalSizeNeeded += (lstrlen(pGroup->lpszName) + 1) * sizeof(TCHAR);
        }

        pGroup = pGroup->pNext;
    }

    pGroupList->dwNeededSize = dwTotalSizeNeeded;
    
    if (pGroupList->dwTotalSize < dwTotalSizeNeeded)
    {
        pGroupList->dwUsedSize = sizeof(LINEAGENTGROUPLIST);

        return 0;
//        return LINEERR_STRUCTURETOOSMALL;
    }

    pGroupList->dwNumEntries = dwNumEntries;

    // set the list info
    pGroupList->dwListSize = sizeof(LINEAGENTGROUPENTRY) * pGroupList->dwNumEntries;
    pGroupList->dwListOffset = sizeof(LINEAGENTGROUPLIST);

    // get the first agentgroup entry struct
    pEntry = (LPLINEAGENTGROUPENTRY)(((LPBYTE)pGroupList) + pGroupList->dwListOffset);

    dwNameOffset = pGroupList->dwListOffset + pGroupList->dwListSize;
    pGroup = g.pGroups;

    // loop through the groups again, and fill in the structure
    while (pGroup)
    {
        if (IsAgentInList(pGroup->pAgentList,
                          pAgent))
        {
            // ID is just PGROUP
            pEntry->GroupID.dwGroupID1 = (DWORD)pGroup;
            pEntry->GroupID.dwGroupID2 = 0;
            pEntry->GroupID.dwGroupID3 = 0;
            pEntry->GroupID.dwGroupID4 = 0;

            // set name of group
            pName = (LPTSTR)(((LPBYTE)pGroupList) + dwNameOffset);
                
            pEntry->dwNameSize = (lstrlen(pGroup->lpszName) + 1) * sizeof(TCHAR);
            pEntry->dwNameOffset = dwNameOffset;
            lstrcpy(pName,
                    pGroup->lpszName);

            dwNameOffset += pEntry->dwNameSize;

            // get next entry
            pEntry++;
        }

        pGroup = pGroup->pNext;
    }

    pGroupList->dwUsedSize = dwTotalSizeNeeded;
    
    return 0;
}



////////////////////////////////////////////////////////////////////////////
//
//  LRESULT SetGroupList()
//
//   Sets the groups that the agent is logged into.
//     This does not change the groups that the agent _can_ log into
//
////////////////////////////////////////////////////////////////////////////
LRESULT SetGroupList(PAGENT pAgent,
                     DWORD dwAddress,
                     LPLINEAGENTGROUPLIST pGroupList)
{
    LPLINEAGENTGROUPENTRY   pGroupEntry;
    PLISTITEM               pListEntry;
    DWORD                   i;
    PGROUP  *               ppGroups = NULL;
    PGROUP                  pGroup;

    ppGroups = (PGROUP*)ACDAlloc(sizeof(PGROUP) * pGroupList->dwNumEntries);
    
    // get to the group entry struct
    pGroupEntry = (LPLINEAGENTGROUPENTRY)(((LPBYTE)pGroupList) + pGroupList->dwListOffset);

    // loop through all entries
    for (i = 0; i < pGroupList->dwNumEntries; i++)
    {
        // get the group in entry
        // NOTE! NOTE! NOTE!
        // should protect here against bad pointers !!!
        pGroup = (PGROUP)pGroupEntry->GroupID.dwGroupID1;

        if (pGroup->dwKey != GROUPKEY)
        {
            return LINEERR_INVALAGENTGROUP;
        }
        
        pListEntry = pGroup->pAgentList;

        // walk list of agents in that group
        if (!IsAgentInList(pGroup->pAgentList,
                           pAgent))
        {
            ACDFree(ppGroups);
            return LINEERR_INVALAGENTGROUP;
        }

        // save group for easy access
        ppGroups[i] = pGroup;
        
        // get the next entry (after the variable portion of
        // the previous entry struct)
        pGroupEntry++;
    }

    // now we know that the groups to be set are valid
    // walk through the list of groups again, and
    // set the status to logged in/ not logged in
    // for every group that the agent is a member of

    pGroup = g.pGroups;
    
    // walk list of all groups
    while (pGroup)
    {
        if (pListEntry = IsAgentInList(pGroup->pAgentList,
                                       pAgent))
        {
            // default to not logged in
            pListEntry->bLoggedIn = FALSE;

            // loop through groups being set
            for (i = 0; i < pGroupList->dwNumEntries; i++)
            {
                // if this group is in list, set agent to logged in
                if (pGroup == ppGroups[i])
                {
                    pListEntry->bLoggedIn = TRUE;
                    // assumption:  agent can only log into a group on one address.
                    pListEntry->dwAddress = dwAddress;
                    break;
                }
                
            } // for
            
        }  // agent in list

        // next group
        pGroup = pGroup->pNext;
        
    } // while


    ACDFree(ppGroups);
    
    return 0;
}


/////////////////////////////////////////////////////////////////////////
//
//  BOOL MakeAgentActivityList()
//
//    Creates a LINEAGENTACTIVITYLIST for pAgent
//
//    for the sample, just generic names are used
//    "Activity 1", "Activity 2"....
//
/////////////////////////////////////////////////////////////////////////
LRESULT MakeAgentActivityList(PAGENT pAgent,
                              LPLINEAGENTACTIVITYLIST pActivityList)
{
    TCHAR                       szBuffer[64];
    DWORD                       dwTotalSize, dwNameOffset, i, dwNumEntries;
    LPTSTR                      pName;
    LPLINEAGENTACTIVITYENTRY    pEntry;

    // init
    dwTotalSize = sizeof(LINEAGENTACTIVITYLIST);
    pActivityList->dwNumEntries = 0;
    dwNumEntries = 0;
    
    // just a static list of activities
    for (i = 0; i < TOTALACTIVITIES; i++)
    {
        dwNumEntries++;

        // create a name
        wsprintf(szBuffer, TEXT("Activity %lu"), i);

        // determine size of this entry
        dwTotalSize += sizeof(LINEAGENTACTIVITYENTRY);
        dwTotalSize += (lstrlen(szBuffer) + 1) * sizeof(TCHAR);
    }

    pActivityList->dwNeededSize = dwTotalSize;
    
    // verify size
    if (pActivityList->dwTotalSize < dwTotalSize)
    {
        pActivityList->dwUsedSize = sizeof(LINEAGENTACTIVITYLIST);

        return 0;
//        return LINEERR_STRUCTURETOOSMALL;
    }

    pActivityList->dwNumEntries = dwNumEntries;
    
    // set list stuff
    pActivityList->dwListSize = sizeof(LINEAGENTACTIVITYENTRY) * pActivityList->dwNumEntries;
    pActivityList->dwListOffset = sizeof(LINEAGENTACTIVITYLIST);

    // get first activityentry
    pEntry = (LPLINEAGENTACTIVITYENTRY)(((LPBYTE)pActivityList) + pActivityList->dwListOffset);
    dwNameOffset = pActivityList->dwListOffset + pActivityList->dwListSize;

    // loop through activities again
    for (i = 0; i < TOTALACTIVITIES; i++)
    {
        // fill in members
        pEntry->dwID = i;

        // create a name
        wsprintf(szBuffer, TEXT("Activity %lu"), i);

        pName = (LPTSTR)(((LPBYTE)pActivityList) + dwNameOffset);
        
        pEntry->dwNameSize = (lstrlen(szBuffer) + 1) * sizeof(TCHAR);
        pEntry->dwNameOffset = dwNameOffset;
        lstrcpy(pName,
                szBuffer);

        dwNameOffset += pEntry->dwNameSize;
        
        pEntry++;

    } // for

    // fill in used size
    pActivityList->dwUsedSize = dwTotalSize;
    
    return 0;
}


#define DWAGENTFEATURES         LINEAGENTFEATURE_SETAGENTGROUP | \
                                LINEAGENTFEATURE_SETAGENTSTATE | \
                                LINEAGENTFEATURE_SETAGENTACTIVITY | \
                                LINEAGENTFEATURE_GETAGENTACTIVITYLIST | \
                                LINEAGENTFEATURE_GETAGENTGROUP

#define DWSTATES                LINEAGENTSTATE_LOGGEDOFF | \
                                LINEAGENTSTATE_NOTREADY | \
                                LINEAGENTSTATE_READY | \
                                LINEAGENTSTATE_BUSYACD | \
                                LINEAGENTSTATE_BUSYINCOMING | \
                                LINEAGENTSTATE_BUSYOUTBOUND | \
                                LINEAGENTSTATE_BUSYOTHER | \
                                LINEAGENTSTATE_WORKINGAFTERCALL | \
                                LINEAGENTSTATE_UNKNOWN | \
                                LINEAGENTSTATE_UNAVAIL

#define DWNEXTSTATES            LINEAGENTSTATE_LOGGEDOFF | \
                                LINEAGENTSTATE_NOTREADY | \
                                LINEAGENTSTATE_READY | \
                                LINEAGENTSTATE_BUSYACD | \
                                LINEAGENTSTATE_BUSYINCOMING | \
                                LINEAGENTSTATE_BUSYOUTBOUND | \
                                LINEAGENTSTATE_BUSYOTHER | \
                                LINEAGENTSTATE_WORKINGAFTERCALL | \
                                LINEAGENTSTATE_UNKNOWN | \
                                LINEAGENTSTATE_UNAVAIL

#define DWSTATUSMESSAGES        LINEAGENTSTATUS_GROUP | \
                                LINEAGENTSTATUS_STATE | \
                                LINEAGENTSTATUS_NEXTSTATE | \
                                LINEAGENTSTATUS_ACTIVITY | \
                                LINEAGENTSTATUS_ACTIVITYLIST | \
                                LINEAGENTSTATUS_GROUPLIST | \
                                LINEAGENTSTATUS_CAPSCHANGE | \
                                LINEAGENTSTATUS_VALIDSTATES | \
                                LINEAGENTSTATUS_VALIDNEXTSTATES


////////////////////////////////////////////////////////////////////
//
//  BOOL IsValidState(DWORD dwState)
//
////////////////////////////////////////////////////////////////////
BOOL IsValidState(DWORD dwState)
{
    if (!dwState)
    {
        return TRUE;
    }

    if ((dwState) & (dwState - 1))
    {
        // more than one bit set
        return FALSE;
    }

    // make sure it's one of the valid states
    return (dwState & DWSTATES);

}


////////////////////////////////////////////////////////////////////
//
//  BOOL IsValidNextState(DWORD dwState)
//
////////////////////////////////////////////////////////////////////
BOOL IsValidNextState(DWORD dwState)
{
    if (!dwState)
    {
        return TRUE;
    }

    if ((dwState) & (dwState - 1))
    {
        // more than one bit set
        return FALSE;
    }

    // make sure it's one of the valid states
    return (dwState & DWNEXTSTATES);

}


///////////////////////////////////////////////////////////////////////
//
//  BOOL IsValidActivityID(DWORD dwActivityID)
//
///////////////////////////////////////////////////////////////////////
BOOL IsValidActivityID(DWORD dwActivityID)
{
    return (dwActivityID <= TOTALACTIVITIES);
}



////////////////////////////////////////////////////////////////////////
//
//  LRESULT MakeAgentCaps(PAGENT pAgent,
//                        LPLINEAGENTCAPS pAgentCaps)
//
//    Creates a LINEAGENTCAPS for pAgent
//    Features/states/messages are hardcoded
//     for this example
//
////////////////////////////////////////////////////////////////////////
LRESULT MakeAgentCaps(PAGENT pAgent,
                      LPLINEAGENTCAPS pAgentCaps)
{
    DWORD       dwStringSize;
    
    dwStringSize = (lstrlen(SZAPPNAME) + 1) * sizeof(TCHAR);

    pAgentCaps->dwNeededSize = sizeof(LINEAGENTCAPS) + dwStringSize;

    if (pAgentCaps->dwTotalSize < pAgentCaps->dwNeededSize)
    {
        pAgentCaps->dwUsedSize = sizeof(LINEAGENTCAPS);
        return 0;
//        return LINEERR_STRUCTURETOOSMALL;
    }

    
    pAgentCaps->dwAgentHandlerInfoSize = dwStringSize;
    pAgentCaps->dwAgentHandlerInfoOffset = sizeof(LINEAGENTCAPS);

    pAgentCaps->dwCapsVersion = TAPI_CURRENT_VERSION;

    // these features are hardcoded here.
    // a real implementation may set specific features
    // per agent or line or address
    pAgentCaps->dwFeatures              = DWAGENTFEATURES;
    pAgentCaps->dwStates                = DWSTATES;
    pAgentCaps->dwNextStates            = DWNEXTSTATES;
    pAgentCaps->dwMaxNumGroupEntries    = NUMGROUPENTRIES;
    pAgentCaps->dwAgentStatusMessages   = DWSTATUSMESSAGES;

    // no extensions
    pAgentCaps->dwNumAgentExtensionIDs = 0;
    pAgentCaps->dwAgentExtensionIDListSize = 0;
    pAgentCaps->dwAgentExtensionIDListOffset = 0;


    pAgentCaps->dwUsedSize = pAgentCaps->dwNeededSize;
    
    return 0;
}


//////////////////////////////////////////////////////////////////////////
//
//  LRESULT GetAgentStatus()
//
//  Creates a LINEAGENTSTATUS for pAgent
//
//////////////////////////////////////////////////////////////////////////
LRESULT GetAgentStatus(PAGENT pAgent,
                       DWORD dwAddress,
                       LPLINEAGENTSTATUS pAgentStatus)
{
    PGROUP                  pGroup;
    LPLINEAGENTGROUPENTRY   pGroupEntry;
    DWORD                   dwTotalSize, dwNameOffset, dwCount;
    TCHAR                   szActivityName[NAMESIZE];
    PGROUP *                ppGroups;
    PLISTITEM               pEntry;

    // init total size
    dwTotalSize = sizeof(LINEAGENTSTATUS);

    if (dwAddress >= pAgent->dwNumAddresses)
    {
        return LINEERR_INVALADDRESSID;
    }
    
    // set know members
    // for valid states / next states / agent features, just setting it to
    // generic stuff.  a real implementation may want to set these
    // field depending on current state / agent / hline
    pAgentStatus->dwState           = pAgent->pAddressInfo[dwAddress].dwState;
    pAgentStatus->dwNextState       = pAgent->pAddressInfo[dwAddress].dwNextState;
    pAgentStatus->dwActivityID      = pAgent->pAddressInfo[dwAddress].dwActivity;
    pAgentStatus->dwAgentFeatures   = DWAGENTFEATURES;
    pAgentStatus->dwValidStates     = DWSTATES;
    pAgentStatus->dwValidNextStates = DWNEXTSTATES;

    // create the activity name
    wsprintf(szActivityName, TEXT("Activity %lu"), pAgent->pAddressInfo[dwAddress].dwActivity);
    dwTotalSize += (lstrlen(szActivityName) + 1) * sizeof(TCHAR);

    ppGroups = (PGROUP *)ACDAlloc(sizeof(PGROUP) * g.dwNumGroups);

    pGroup = g.pGroups;

    pAgentStatus->dwNumEntries = 0;

    // walk list of groups
    while (pGroup)
    {
        pEntry = pGroup->pAgentList;

        // walk each agent in each group
        while (pEntry)
        {
            if (pEntry->pAgent == pAgent)
            {
                if ((!pEntry->bLoggedIn) ||
                    (pEntry->dwAddress != dwAddress))
                {
                    break;
                }

                // save group
                ppGroups[pAgentStatus->dwNumEntries] = pGroup;

                // adjust total size / entries
                pAgentStatus->dwNumEntries++;
                dwTotalSize += sizeof(LINEAGENTGROUPENTRY);
                dwTotalSize += (lstrlen(pGroup->lpszName) + 1) * sizeof(TCHAR);

                break;
            }

            pEntry = pEntry->pNext;
            
        }  // while (pEntry)

        pGroup = pGroup->pNext;
        
    } // while (pGroup)

    // set needed size
    pAgentStatus->dwNeededSize = dwTotalSize;

    // do we have enough room?
    if (pAgentStatus->dwTotalSize < dwTotalSize)
    {
        // if not, return
        pAgentStatus->dwUsedSize = sizeof(LINEAGENTSTATUS);
        ACDFree(ppGroups);

        return 0;
//        return LINEERR_STRUCTURETOOSMALL;
    }


    // set the group entries...

    // first get the offset to the first entry
    pGroupEntry = (LPLINEAGENTGROUPENTRY)(((LPBYTE)pAgentStatus) + sizeof(LINEAGENTSTATUS));
    pAgentStatus->dwGroupListOffset = sizeof(LINEAGENTSTATUS);

    // figure out where the names can go (after all the fixed structures)
    dwNameOffset = sizeof(LINEAGENTSTATUS) +
                   sizeof(LINEAGENTGROUPENTRY) * pAgentStatus->dwNumEntries;

    // loop through all the group that the agent is logged into
    for (dwCount = 0; dwCount < pAgentStatus->dwNumEntries; dwCount++)
    {
        // set the it (just the pGroup)
        pGroupEntry->GroupID.dwGroupID1 = (DWORD)ppGroups[dwCount];
        pGroupEntry->GroupID.dwGroupID2 = 0;
        pGroupEntry->GroupID.dwGroupID3 = 0;
        pGroupEntry->GroupID.dwGroupID4 = 0;

        // set name size and offset
        pGroupEntry->dwNameSize = (lstrlen(ppGroups[dwCount]->lpszName) + 1) * sizeof(TCHAR);
        pGroupEntry->dwNameOffset = dwNameOffset;

        // copy name
        lstrcpy((LPTSTR)(((LPBYTE)pAgentStatus) + dwNameOffset),
                ppGroups[dwCount]->lpszName);

        // fix the name offset
        dwNameOffset += pGroupEntry->dwNameSize;

        // next entry
        pGroupEntry++;
        
    }

    pAgentStatus->dwGroupListSize = dwNameOffset - pAgentStatus->dwGroupListOffset;
    
    // put the activity name at the end
    pAgentStatus->dwActivitySize = (lstrlen(szActivityName) + 1) * sizeof(TCHAR);
    pAgentStatus->dwActivityOffset = dwNameOffset;

    lstrcpy((LPTSTR)(((LPBYTE)pAgentStatus) + dwNameOffset),
            szActivityName);

    
    ACDFree(ppGroups);

    pAgentStatus->dwUsedSize = pAgentStatus->dwNeededSize;
    // return success
    return 0;
}


/////////////////////////////////////////////////////////////////////
//
//  LRESULT SetAgentState()
//
//    Sets the current and next state for pAgent
//    on that specific address
//
//
/////////////////////////////////////////////////////////////////////
LRESULT SetAgentState(PAGENT pAgent,
                      DWORD dwAddress,
                      DWORD dwState,
                      DWORD dwNextState)
{
    // make sure valid
    if ((!IsValidState(dwState)) ||
        (!IsValidNextState(dwNextState)))
    {
        return LINEERR_INVALAGENTSTATE;
    }

    // check address
    if (dwAddress >= pAgent->dwNumAddresses)
    {
        return LINEERR_INVALADDRESSID;
    }

    // set the state if specified
    if (dwState)
    {
        pAgent->pAddressInfo[dwAddress].dwState = dwState;
    }

    if (dwNextState)
    {
        pAgent->pAddressInfo[dwAddress].dwNextState = dwNextState;
    }
    
    return 0;
}


///////////////////////////////////////////////////////////////////////////////
//
//  LRESULT SetAgentActivity()
//
//   Sets the activity for pAgent
//
///////////////////////////////////////////////////////////////////////////////
LRESULT SetAgentActivity(PAGENT pAgent,
                         DWORD dwAddress,
                         DWORD dwActivityID)
{
    if (dwAddress >= pAgent->dwNumAddresses)
    {
        return LINEERR_INVALADDRESSID;
    }

    if (!IsValidActivityID(dwActivityID))
    {
        return LINEERR_INVALAGENTACTIVITY;
    }

    pAgent->pAddressInfo[dwAddress].dwActivity = dwActivityID;
    
    return 0;
}


////////////////////////////////////////////////////////////////////////////////
//
//  BOOL HandleOffering(HCALL hCall)
//
//    Handles a LINECALLSTATE_OFFERING message
//      Determines the group associated with the address
//      that the call came in on, finds an available
//      agent in that group, and transfers the call to that
//      agent.
//
////////////////////////////////////////////////////////////////////////////////
BOOL HandleOffering(HCALL hCall)
{
    LPLINECALLINFO      pLCI;
    PGROUP              pGroup;
    PLISTITEM           pEntry;
    LONG                lResult;
    
    pLCI = LineGetCallInfo(hCall);

    if (!pLCI)
    {
        return FALSE;
    }

    pGroup = g.pGroups;

    // find the group that this call came in on
    // walk all the groups
    while (pGroup)
    {
        // if the line and address match, it's the
        // correct address
        if ((pGroup->hLine == pLCI->hLine) &&
            (pGroup->dwAddress == pLCI->dwAddressID))
        {
            break;
        }

        pGroup = pGroup->pNext;
    }

    // couldn't find the group
    if (!pGroup)
    {
        // error!
        ACDFree(pLCI);
        return FALSE;
    }

    // OK - found the group that this call is for.  Now transfer to
    // an agent that is available.
    pEntry = pGroup->pAgentList;

    while (pEntry)
    {
        if (pEntry->bLoggedIn &&
            (pEntry->pAgent->pAddressInfo[pEntry->dwAddress].dwState ==
                LINEAGENTSTATE_READY))
        {
            // found someone
            // doing a blind transfer here
            // other implementations may need to
            // do lineSetupTransfer / lineDial / lineCompleteTransfer
            if (lResult = lineBlindTransfer(hCall,
                                            (LPCWSTR)pEntry->pAgent->lpszNumber,
                                            0))
            {
                //LogTapiError(TEXT("lineBlindTransfer"), lResult);
                // don't break - try the next agent
            }
            else
            {
                // set the state to reflect that
                // a call is being handled
                SetAgentState(pEntry->pAgent,
                              pEntry->dwAddress,
                              LINEAGENTSTATE_BUSYACD,
                              LINEAGENTSTATE_READY);

                break;
            }

        }
        
        pEntry = pEntry->pNext;
    }

    if (!pEntry)
    {
        // couldn't find an available agent

        // NOTE! NOTE! NOTE! NOTE! NOTE!
        // something should be done here with this call.  put into
        // a queue on hold or something.  For this sample, we are just
        // ignoring it
    }

    ACDFree(pLCI);

    return TRUE;
}


//////////////////////////////////////////////////////////////////////////
//
//  BOOL HandleIdle(HCALL hCall)
//
//    Handles LINECALLSTATE_IDLE
//     Should always always always deallocate when
//     getting an IDLE message.  Also, determine if this is a call
//     that we know about and set the agent state appropriatly
//
//////////////////////////////////////////////////////////////////////////
BOOL HandleIdle(HCALL hCall)
{
    LPLINECALLINFO      pLCI;
    PAGENT              pAgent;

    pLCI = LineGetCallInfo(hCall);

    // always deallocate the call
    lineDeallocateCall(hCall);

    if (!pLCI)
    {
        return FALSE;
    }

    // get the agent associated with the line
    pAgent = GetAgentFromhLine(pLCI->hLine);

    if (!pAgent)
    {
        ACDFree(pLCI);
        return FALSE;
    }
              

    // set that agent to their next state
    // Assumption:  only calls that the ACD app know about
    // occur.  For example, if an agent made an outgoing call
    // and it transitioned to idle, this code would still be executed.
    // May make more sense to not handle NextState in the ACD app, and let
    // the client app handle it.
    SetAgentState(pAgent,
                  pLCI->dwAddressID,
                  pAgent->pAddressInfo[pLCI->dwAddressID].dwNextState,
                  0);

    ACDFree(pLCI);
    
    return TRUE;
    
}


////////////////////////////////////////////////////////////////////////////
//
//  void HandleLineProxyRequest(HLINE hLine,
//                              LPLINEPROXYREQUEST pProxyRequest)
//
//    Handles LINE_PROXYREQUEST message
//     Just dispatches to appropriate functions
//
////////////////////////////////////////////////////////////////////////////
void HandleLineProxyRequest(HLINE hLine,
                            LPLINEPROXYREQUEST pProxyRequest)
{
    PAGENT       pAgent;
    LRESULT      lResult;

    pAgent = GetAgentFromName((LPTSTR)(((LPBYTE)pProxyRequest) +
                                       pProxyRequest->dwClientUserNameOffset));
    
    if (!pAgent)
    {
        lineProxyResponse(hLine,
                          pProxyRequest,
                          LINEERR_INVALAGENTID);

        return;
    }
    
    switch (pProxyRequest->dwRequestType)
    {
        case LINEPROXYREQUEST_SETAGENTGROUP:

            lResult = SetGroupList(pAgent,
                                   pProxyRequest->SetAgentGroup.dwAddressID,
                                   &pProxyRequest->SetAgentGroup.GroupList);

            lineProxyResponse(hLine,
                              pProxyRequest,
                              lResult);

            return;
            
        case LINEPROXYREQUEST_SETAGENTSTATE:

            lResult = SetAgentState(pAgent,
                                    pProxyRequest->SetAgentState.dwAddressID,
                                    pProxyRequest->SetAgentState.dwAgentState,
                                    pProxyRequest->SetAgentState.dwNextAgentState);

            lineProxyResponse(hLine,
                              pProxyRequest,
                              lResult);
            
            break;
            
        case LINEPROXYREQUEST_SETAGENTACTIVITY:

            lResult = SetAgentActivity(pAgent,
                                       pProxyRequest->SetAgentActivity.dwAddressID,
                                       pProxyRequest->SetAgentActivity.dwActivityID);

            lineProxyResponse(hLine,
                              pProxyRequest,
                              lResult);
            
            break;
            
        case LINEPROXYREQUEST_GETAGENTSTATUS:

            lResult = GetAgentStatus(pAgent,
                                     pProxyRequest->GetAgentStatus.dwAddressID,
                                     &pProxyRequest->GetAgentStatus.AgentStatus);

            lineProxyResponse(hLine,
                              pProxyRequest,
                              lResult);
            
            break;
            
        case LINEPROXYREQUEST_GETAGENTCAPS:

            if ((hLine == pAgent->hLine) &&
                (pProxyRequest->GetAgentCaps.dwAddressID < pAgent->dwNumAddresses))
            {
                lResult = MakeAgentCaps(pAgent,
                                        &pProxyRequest->GetAgentCaps.AgentCaps);
            }
            else
            {
                lResult = LINEERR_BADDEVICEID;
            }

            lineProxyResponse(hLine,
                              pProxyRequest,
                              lResult);
            break;
            
        case LINEPROXYREQUEST_GETAGENTACTIVITYLIST:

            lResult = MakeAgentActivityList(pAgent,
                                            &pProxyRequest->GetAgentActivityList.ActivityList);

            lineProxyResponse(hLine,
                              pProxyRequest,
                              lResult);
            
            break;
            
        case LINEPROXYREQUEST_GETAGENTGROUPLIST:

            lResult = MakeGroupList(pAgent,
                                    &pProxyRequest->GetAgentGroupList.GroupList);

            lineProxyResponse(hLine,
                              pProxyRequest,
                              lResult);
            return;
            

    }
    return;
}

/////////////////////////////////////////////////////////////
//
//  void HandleLineCallState(DWORD dwDevice,
//
//  Handles callstate messages we are interested in
//
/////////////////////////////////////////////////////////////
void HandleLineCallState(DWORD dwDevice,
                         DWORD dwParam1,
                         DWORD dwParam2,
                         DWORD dwParam3)
{
    switch (dwParam1)
    {
    case LINECALLSTATE_OFFERING:
    {
        LPLINECALLSTATUS        pLCS;

        // get the call privilege.
        // NOTE:  the new LINE_APPNEWCALL message notifies applications
        // of their priv for new calls not created by app
        pLCS = LineGetCallStatus((HCALL)dwDevice);
        if (!pLCS)
        {
            break;
        }
        
        if (pLCS->dwCallPrivilege & LINECALLPRIVILEGE_OWNER)
        {
            HandleOffering((HCALL)dwDevice);
        }

        ACDFree(pLCS);
        
        break;
    }
    case LINECALLSTATE_CONNECTED:
        break;

    case LINECALLSTATE_DISCONNECTED:
        break;

    case LINECALLSTATE_IDLE:

        HandleIdle((HCALL)dwDevice);
        
        break;

    case LINECALLSTATE_BUSY:
        break;

    default:
        break;
    }
}


///////////////////////////////////////////////////////////////////////
// TAPI message handlers.  For this sample, they don't
// do anything
///////////////////////////////////////////////////////////////////////
void HandleLineDevState(DWORD dwParam1,
                        DWORD dwParam2,
                        DWORD dwParam3)
{
}


void HandleLineReply(DWORD dwParam1,
                     DWORD dwParam2,
                     DWORD dwParam3)
{
}
void HandleLineCallInfo(DWORD dwParam1,
                             DWORD dwParam2,
                             DWORD dwParam3)
{
}

void HandleLineClose(DWORD dwParam1,
                          DWORD dwParam2,
                          DWORD dwParam3)
{
}


//////////////////////////////////////////////////////////////////////////////////
//
// LineCallback() - TAPI callback function
//
//////////////////////////////////////////////////////////////////////////////////
VOID CALLBACK LineCallback (DWORD hDevice,
                            DWORD dwMsg,
                            DWORD dwCallbackInstance, 
                            DWORD dwParam1,
                            DWORD dwParam2, 
                            DWORD dwParam3)
{
    switch(dwMsg)
    {
      case LINE_PROXYREQUEST:
           HandleLineProxyRequest((HLINE) hDevice,
                                  (LPLINEPROXYREQUEST)dwParam1);
           return;
           
      case LINE_LINEDEVSTATE:
          HandleLineDevState(dwParam1,
                             dwParam2,
                             dwParam3);
          return;
      case LINE_REPLY:
          HandleLineReply(dwParam1,
                          dwParam2,
                          dwParam3);
          return;
      case LINE_CALLSTATE:
          HandleLineCallState(hDevice,
                              dwParam1,
                              dwParam2,
                              dwParam3);
          return; 
      case LINE_CALLINFO:
          HandleLineCallInfo(dwParam1,
                             dwParam2,
                             dwParam3);
          return;
      case LINE_CLOSE:
          HandleLineClose(dwParam1,
                          dwParam2,
                          dwParam3);
          return;

      default:
          return;
   }
}