tapicom.pas

boomerang library 5.11 internet ed

  try
    TapiCheck(lineGetDevCaps(FLineApp, aDeviceID, APIVersions[aDeviceId], 0, lpLineDevCaps_));
    if ((lpLineDevCaps_^.dwLineNameSize <> 0) and
       (lpLineDevCaps_^.dwLineNameOffset <> 0) and
       (lpLineDevCaps_^.dwStringFormat = STRINGFORMAT_ASCII)) then
      begin
        Result:= _StrCopy(lpLineDevCaps_, lpLineDevCaps_^.dwLineNameOffset, lpLineDevCaps_^.dwLineNameSize);
        if Result = '' then
          Result:= stLineNameEmpty;
      end
    else  // DevCaps doesn't have a valid line name.  Unnamed.
      Result:= stLineUnnamed;
  finally
    FreeMem (lpLineDevCaps_);
  end;
end;

function TTAPILine.GetAPIVersion;
var
  Ext : TLINEEXTENSIONID;
begin
  CheckActive;
  TapiCheck(lineNegotiateAPIVersion(LineApp, aDeviceId, TAPILoVer, TAPIHiVer, @Result, @Ext));
end;

procedure TTAPILine.SetDevConfig;
begin
  TapiCheck(lineSetDevConfig(aDeviceId, @Value[1], Length(Value), 'comm/datamodem'));
end;

function TTapiLine.GetDevConfig;
var
  lpVarString_: LPVARSTRING;
begin
  lpVarString_:= GetTapiMem(SizeOf(lpVarString_^));
  try
    TapiCheck(lineGetDevConfig(aDeviceId, lpVarString_,'comm/datamodem'));
    SetLength(Result, lpVarString_^.dwStringSize);
    Move(PChar(lpVarString_)[lpVarString_^.dwStringOffset], Result[1], Length(Result));
  finally
    FreeMem(lpVarString_);
  end;
end;

procedure TTAPILine.HandleCallback;
var
  I: Integer;
begin
  if Assigned(FOnHandleCallback) then
    FOnHandleCallback(aDevice, aMessage, aInstance, aParam1, aParam2, aParam3);
  if aMessage in (LineCallbacks+CallCallbacks+NoDeviceCallbacks) then
    for I:= 0 to FList.Count-1 do
      if DWORD(FList[I]) = aInstance then
      begin
        TLineCom(FList[I]).HandleCallback(aDevice, aMessage, aParam1, aParam2, aParam3);
      end;
end;

function TTAPILine.FindDeviceId;
var
  I: Integer;
begin
  Result:= MAXDWORD;
  for I:= 0 to FNumDevs-1 do
    try
      if LineNames[I] = aDeviceName then
      begin
        Result:= I;
        Break;
      end;
    except
    end;
end;

procedure TTAPILine.ShowConfigDialog;
begin
  CheckActive;
  TapiCheck(lineConfigDialog(aDeviceId, Application.Handle, 'comm/datamodem'));
end;

procedure TTAPILine.ShowTranslateDialog;
begin
  TapiLine.CheckActive;
  TapiCheck(lineTranslateDialog(LineApp, aDeviceId, APIVersions[aDeviceId], Application.Handle, PChar(aPhoneNumber)));
end;

constructor TLineCom.Create;
begin
  inherited;
  FDeviceId:= MAXDWORD;
  FComm:= TLineCommHandle.Create(nil);
  FComm.MonitorEvents:= [evRxChar];
  FComm.DontSynchronize:= True;   // multithreaded
  FComm.FLineCom:= Self;
end;

destructor TLineCom.Destroy;
begin
  Close;
  DeviceId:= MAXDWORD;  // close line if opened
  FComm.Free;
  inherited;
end;

procedure TLineCom.HandleCallback;
var
  F: Boolean;
  lpVarString_: LPVARSTRING;
  hCommDev : THandle;
begin
  if Assigned(FOnHandleCallback) then
    FOnHandleCallback(aDevice, aMessage, aParam1, aParam2, aParam3);
  case aMessage of
    LINE_CALLSTATE:
      begin
        case aParam1 of
          LINECALLSTATE_CONNECTED: // CONNECTED!!!
            begin
              if not Connected then
              begin
                FhCommDev := INVALID_HANDLE_VALUE;
                lpVarString_:= GetTapiMem(SizeOf(lpVarString_^));
                try
                  TapiCheck (lineGetID (FLine, 0, FCall, LINECALLSELECT_CALL, lpVarString_, 'comm/datamodem'));
                  Move(PChar(lpVarString_)[lpVarString_^.dwStringOffset], hCommDev, SizeOf(hCommDev));
                  FComm.hCommDev:= hCommDev;
                finally
                  FreeMem(lpVarString_);
                end;
                FComm.Open;
              end;
            end;
          LINECALLSTATE_OFFERING:
            if not Connected then
            begin
              F:= False;
              if Assigned(FOnCallOffering) then
                FOnCallOffering(Self, F);
              if F then
              begin
                FCall := hCALL (aDevice);
                FRequestAnswer:= TapiCheck(lineAnswer(FCall, nil, 0));
              end;
            end;
          LINECALLSTATE_IDLE:
            begin
              FComm.Close;
              if FCall.Unused <> 0 then
              begin
                lineDeallocateCall(FCall);
                FCall.Unused:= 0;
              end;
            end;
          LINECALLSTATE_DISCONNECTED:   // remote party has disconnected
            begin
              Drop;
            end;
        end;
        if Assigned(FOnStateChange) then
          FOnStateChange(Self, aParam1, aParam2);
      end;
    LINE_REPLY:
      begin
        if aParam1 = FRequestAnswer then
        begin
          TapiCheck (aParam2);
          if Assigned (FOnCallAnswering) then
            FOnCallAnswering (Self);
          FRequestAnswer := 0;
        end;
        if aParam1 = FRequestMakeCall then
        begin
          FRequestMakeCall := 0;
          TapiCheck (aParam2);
        end;
        if aParam1 = FRequestDrop then
        begin
          FRequestDrop := 0;
          TapiCheck (aParam2);
        end;
      end;
    LINE_CLOSE:
      begin
      end;
  end;
end;

function TLineCom.GetIsMakingCall: Boolean;
begin
  Result:= FRequestMakeCall <> 0;
end;

function TLineCom.GetIsDropping: Boolean;
begin
  Result:= FRequestDrop <> 0;
end;

function TLineCom.GetIsAnswering: Boolean;
begin
  Result:= FRequestAnswer <> 0;
end;

procedure TLineCom.CheckDeviceId;
begin
  if FDeviceId = MAXDWORD then
    TAPIError(errBadDeviceId);
end;

function TLineCom.GetLineApp;
begin
  Result:= TAPILine.LineApp;
end;

procedure TLineCom.OpenConn;
begin
  CheckDeviceId;
  TAPILine.AddLine(Self);
  TapiCheck(lineOpen(LineApp, FDeviceId, @FLine, APIVersion, 0, DWORD(Self){callback instance}, LINECALLPRIVILEGE_OWNER, LINEMEDIAMODE_DATAMODEM, nil));
end;

procedure TLineCom.SetPhoneNumber;
begin
  CheckDisconnected;
  FPhoneNumber:= Value;
end;

procedure TLineCom.SetDirectAccess;
begin
  CheckDisconnected;
  FDirectAccess:= Value;
end;

function TLineCom.GetTranslatedPhoneNumber;
var
  TranslateOutput: LPLINETRANSLATEOUTPUT;
begin
  TranslateOutput:= GetTapiMem(SizeOf(TranslateOutput^));
  try
    lineTranslateAddress(LineApp, DeviceId, APIVersion, PChar(FPhoneNumber), 0, 0, TranslateOutput);
    Result:= _StrCopy(TranslateOutput, TranslateOutput^.dwDialableStringOffset, TranslateOutput^.dwDialableStringSize);
  finally
    FreeMem(TranslateOutput);
  end;
end;

procedure TLineCom.SetDevConfig;
begin
  TapiLine.DevConfig[DeviceId]:= Value;
end;

function TLineCom.GetDevConfig;
begin
  Result:= TapiLine.DevConfig[DeviceId];
end;

procedure TLineCom.CloseConn;
begin
  if FLine.unused <> 0 then
    TapiCheck(lineClose(FLine));
  TAPILine.RemoveLine(Self);
end;

function TLineCom.GetAPIVersion;
begin
  Result:= TAPILine.APIVersions[FDeviceId];
end;

procedure TLineCom.SetDeviceId;
begin
  CheckInactive;
  if FDeviceId <> Value then
    FDeviceId:= Value;
end;

procedure TLineCom.ShowTranslateDialog;
begin
  TapiLine.CheckActive;
  TapiLine.ShowTranslateDialog(DeviceId, FPhoneNumber);
end;

function TLineCom.GetConnected;
begin
  Result:= FComm.Active;
end;

procedure TLineCom.CheckConnected;
begin
  if not Connected then
    TapiError(errNotConnected);
end;

procedure TLineCom.CheckDisconnected;
begin
  if Connected then
    TapiError(errNotDisconnected);
end;

procedure TLineCom.MakeCall;
var
  LineCallParams: TLINECALLPARAMS;
  TranslateOutput: lPLINETRANSLATEOUTPUT;
begin
  CheckActive;
  CheckDisconnected;

  if FRequestMakeCall > 0 then
    TapiError(errCallInProcess);

  FillChar(LineCallParams, SizeOf(LineCallParams), 0);
  with LineCallParams do
  begin
    dwTotalSize:= SizeOf(LineCallParams);
    if FDirectAccess then dwBearerMode:=LINEBEARERMODE_PASSTHROUGH
                     else dwBearerMode:=LINEBEARERMODE_VOICE;
    dwMediaMode:=LINEMEDIAMODE_DATAMODEM;
  end;
  if FDirectAccess then
    FRequestMakeCall:= TapiCheck(lineMakeCall(Line, @FCall, nil, 0, @LineCallParams))
  else
    begin
      TranslateOutput:= GetTapiMem(SizeOf(TranslateOutput^));
      try
        lineTranslateAddress(LineApp, DeviceId, APIVersion, PChar(FPhoneNumber), 0, 0, TranslateOutput);
        FRequestMakeCall:= TapiCheck(lineMakeCall(Line, @FCall, PChar(_StrCopy(TranslateOutput, TranslateOutput^.dwDialableStringOffset, TranslateOutput^.dwDialableStringSize)), TranslateOutput^.dwDestCountry, @LineCallParams));
      finally
        FreeMem(TranslateOutput);
      end;
    end;
// FCall will be valid after Line_Reply callback
end;

procedure TLineCom.Drop;
begin
  if FRequestDrop = 0 then
    if FCall.Unused <> 0 then
      FRequestDrop:= TapiCheck(lineDrop (Call, nil, 0))
end;

procedure TLineCommHandle.DoAfterOpen;
begin
  if Assigned(FLineCom.FOnConnect) then
    FLineCom.FOnConnect(FLineCom);
end;

procedure TLineCommHandle.DoAfterClose;
begin
  if Assigned(FLineCom.FOnDisconnect) then
    FLineCom.FOnDisconnect(FLineCom);
end;

procedure Register;
begin
  RegisterComponents('Communication', [TLineCom]);
end;

initialization
  TAPILine:= TTAPILine.Create(nil);
finalization
  TAPILine.Free;
end.