acdtapi.c

TAPI ACD Samples

///////////////////////////////////////////////////////////////////////////////////
//
//  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);