/// <summary> /// This picks up a call alerting at the specified destination address and returns a call handle for the picked-up call. /// If invoked with null for the alertingAddress parameter, a group pickup is performed. If required by the device, groupId specifies the /// group identifier to which the alerting station belongs. /// </summary> /// <param name="alertingAddress">Address to retrieve call from</param> /// <param name="groupId">Optional group ID, can be null or empty</param> /// <returns>New <see cref="TapiCall"/> object.</returns> public ITapiCall Pickup(string alertingAddress, string groupId) { uint hCall; int rc = NativeMethods.linePickup(_lineOwner.Handle, _addressId, out hCall, alertingAddress, groupId); if (rc < 0) { throw new TapiException("linePickup failed", rc); } // Wait for the LINE_REPLY .. same reason as lineMakeCall.. var req = new PendingTapiRequest(rc, null, null); _lineOwner.TapiManager.AddAsyncRequest(req); req.AsyncWaitHandle.WaitOne(); if (req.Result < 0) { throw new TapiException("linePickup failed", req.Result); } var call = new TapiCall(this, hCall); lock (_calls) { _calls.Add(call); } return(call); }
/// <summary> /// This cancels any forwarding request that is currently in effect on this address /// </summary> public void CancelForward() { uint hCall; int rc = NativeMethods.lineForward(_lineOwner.Handle, 0, _addressId, IntPtr.Zero, 0, out hCall, IntPtr.Zero); if (rc < 0) { throw new TapiException("lineForward failed", rc); } // Wait for the LINE_REPLY so we don't need to deal with the value type // issues of IntPtr being filled in async. var req = new PendingTapiRequest(rc, null, null); _lineOwner.TapiManager.AddAsyncRequest(req); if (req.AsyncWaitHandle.WaitOne(1000, true)) { if (req.Result < 0) { throw new TapiException("lineForward failed", req.Result); } if (hCall != 0) { NativeMethods.lineDeallocateCall(hCall); } } }
/// <summary> /// This retrieves a call off a parked address /// </summary> /// <param name="parkedAddress">Address to retrieve call from</param> /// <returns>New <see cref="TapiCall"/> object.</returns> public TapiCall Unpark(string parkedAddress) { uint hCall; int rc = NativeMethods.lineUnpark(Line.Handle, _addressId, out hCall, parkedAddress); if (rc < 0) { throw new TapiException("lineUnpark failed", rc); } // Wait for the LINE_REPLY .. same reason as lineMakeCall.. var req = new PendingTapiRequest(rc, null, null); Line.TapiManager.AddAsyncRequest(req); req.AsyncWaitHandle.WaitOne(); if (req.Result < 0) { throw new TapiException("lineUnpark failed", req.Result); } var call = new TapiCall(this, hCall); lock (_calls) { _calls.Add(call); } return(call); }
/// <summary> /// This method is used to establish a conference call /// </summary> /// <param name="conferenceCount"># of parties anticipated the conference</param> /// <param name="mcp">Call parameters for created consultation call</param> /// <param name="consultCall">Returning consultation call</param> /// <returns>Conference call</returns> public ITapiCall SetupConference(int conferenceCount, MakeCallParams mcp, out TapiCall consultCall) { IntPtr lpCp = IntPtr.Zero; int callFlags = 0; try { if (mcp != null && !String.IsNullOrEmpty(mcp.TargetAddress)) { callFlags |= NativeMethods.LINECALLPARAMFLAGS_NOHOLDCONFERENCE; } lpCp = MakeCallParams.ProcessCallParams(Id, mcp, callFlags); uint hCall, hConfCall; int rc = NativeMethods.lineSetupConference(new HTCALL(), _lineOwner.Handle, out hConfCall, out hCall, conferenceCount, lpCp); if (rc < 0) { throw new TapiException("lineSetupConference failed", rc); } else { // Wait for the LINE_REPLY so we don't need to deal with the value type // issues of IntPtr being filled in async. var req = new PendingTapiRequest(rc, null, null); _lineOwner.TapiManager.AddAsyncRequest(req); req.AsyncWaitHandle.WaitOne(); if (req.Result < 0) { throw new TapiException("lineSetupConference failed", req.Result); } if (hCall != 0) { consultCall = new TapiCall(this, hCall); AddCall(consultCall); } else { consultCall = null; } var confCall = new TapiCall(this, hConfCall); AddCall(confCall); return(confCall); } } finally { if (lpCp != IntPtr.Zero) { Marshal.FreeHGlobal(lpCp); } } }
/// <summary> /// This forwards calls destined for this address according to the specified forwarding instructions. /// Any specified incoming calls for that address are deflected to the other number by the switch. /// This function provides a combination of forward and do-not-disturb features. /// </summary> /// <param name="forwardInstructions">The forwarding instructions to apply</param> /// <param name="numRingsNoAnswer">Number of rings before a call is considered a "no answer." If dwNumRingsNoAnswer is out of range, the actual value is set to the nearest value in the allowable range.</param> /// <param name="param">Optional call parameters - only used if a consultation call is returned; otherwise ignored. May be null for default parameters</param> public ITapiCall Forward(ForwardInfo[] forwardInstructions, int numRingsNoAnswer, MakeCallParams param) { if (!Line.IsOpen) { throw new TapiException("Line is not open", NativeMethods.LINEERR_OPERATIONUNAVAIL); } IntPtr lpCp = IntPtr.Zero; IntPtr fwdList = ForwardInfo.ProcessForwardList(forwardInstructions); try { lpCp = MakeCallParams.ProcessCallParams(_addressId, param, 0); uint hCall; int rc = NativeMethods.lineForward(_lineOwner.Handle, 0, _addressId, fwdList, numRingsNoAnswer, out hCall, lpCp); if (rc < 0) { throw new TapiException("lineForward failed", rc); } else { // Wait for the LINE_REPLY so we don't need to deal with the value type // issues of IntPtr being filled in async. var req = new PendingTapiRequest(rc, null, null); _lineOwner.TapiManager.AddAsyncRequest(req); req.AsyncWaitHandle.WaitOne(); if (req.Result < 0) { throw new TapiException("lineForward failed", req.Result); } if (hCall != 0) { var call = new TapiCall(this, hCall); AddCall(call); return(call); } } } finally { if (lpCp != IntPtr.Zero) { Marshal.FreeHGlobal(lpCp); } if (fwdList != IntPtr.Zero) { Marshal.FreeHGlobal(fwdList); } } return(null); }
internal IAsyncResult AddAsyncRequest(PendingTapiRequest req) { if (req.AsyncRequestId != 0) { lock (_requests) { _requests.Add(req); } } return(req); }
/// <summary> /// Places a new call on the address /// </summary> /// <param name="address">Number to dial</param> /// <param name="countryCode">Country code</param> /// <param name="param">Optional <see>MakeCallParams</see> to use while dialing</param> /// <returns>New <see cref="TapiCall"/> object.</returns> public ITapiCall MakeCall(string address, int countryCode, MakeCallParams param) { if (!Line.IsOpen) { throw new TapiException("Line is not open", NativeMethods.LINEERR_OPERATIONUNAVAIL); } IntPtr lpCp = IntPtr.Zero; try { lpCp = MakeCallParams.ProcessCallParams(_addressId, param, 0); uint hCall; int rc = NativeMethods.lineMakeCall(_lineOwner.Handle, out hCall, address, countryCode, lpCp); if (rc < 0) { throw new TapiException("lineMakeCall failed", rc); } else { // Wait for the LINE_REPLY so we don't need to deal with the value type // issues of IntPtr being filled in async. var req = new PendingTapiRequest(rc, null, null); _lineOwner.TapiManager.AddAsyncRequest(req); req.AsyncWaitHandle.WaitOne(); if (req.Result < 0) { throw new TapiException("lineMakeCall failed", req.Result); } var call = new TapiCall(this, hCall); AddCall(call); return(call); } } finally { if (lpCp != IntPtr.Zero) { Marshal.FreeHGlobal(lpCp); } } }