[_CDMiwok_01_]<cedarcommon2.0>Finch>FinchSmartsImpl.mesa!1

FinchSmartsImpl.mesa

Last Edited by: Swinehart, September 24, 1990 11:33 am PDT

Doug Terry, September 5, 1986 4:17:06 pm PDT

Polle Zellweger (PTZ) August 14, 1990 4:01:15 pm PDT

DIRECTORY

Atom USING [ GetProp ],

BasicTime USING [ Now, Period, Update ],

Commander USING [ CommandProc, Register ],

CommandTool USING [ ParseToList ],

FinchSmarts,

IO,

LarkFeepSunImport USING [ ImportInterface ],

MBQueue USING [ Create, QueueClientAction ],

NameDB USING [ Error, GetAttribute, SetAttribute ],

Nice,

Process USING [ Detach, SecondsToTicks, SetTimeout ],

RedBlackTree USING [ EachNode, EnumerateIncreasing, Table ],

RefID USING [ ID ],

Rope,

RPC USING [ EncryptionKey ],

ThParty USING [ Advance, Alert, Attributes, ConversationInfo, CreateConversation, DescribeParty, GetConversationFromName, GetConversationInfo, GetParty, GetNumbersForRName, GetPartyFromNumber, GetPartyInfo, LookupServiceInterface, nullIx, PartyInfo, RegisterConversation, Unvisit, UnvisitSelf, Visit ],

Thrush USING [

ActionReport, ConversationID, ConvEvent, Credentials, InterfaceSpec, NB, none, notReallyInConv, nullConvID, nullID, PartyID, PartyType, Reason, ROPE, SHHH, SmartsID, StateInConv ],

ThSmarts,

UserProfile USING [ Boolean ],

VoiceUtils USING [ CurrentPasskey, CurrentRName, Problem, ProblemFR, Registrize, Report, ReportFR ]

;

FinchSmartsImpl: CEDAR MONITOR LOCKS FinchSmarts.lock

IMPORTS Atom, BasicTime, Commander, CommandTool, FinchSmarts, IO, LarkFeepSunImport, MBQueue, NameDB, -- Nice, --Process, RedBlackTree, Rope, ThParty, UserProfile, VoiceUtils

EXPORTS FinchSmarts, ThSmarts = {

OPEN IO;

Declarations

ConvDesc: TYPE = FinchSmarts.ConvDesc;

ConversationID: TYPE = Thrush.ConversationID;

nullConvID: ConversationID = Thrush.nullConvID;

FinchInfo: TYPE = FinchSmarts.FinchInfo;

NB: TYPE = Thrush.NB;

none: SHHH = Thrush.none;

nullID: RefID.ID = Thrush.nullID;

PartyID: TYPE = Thrush.PartyID;

ROPE: TYPE = Thrush.ROPE;

SHHH: TYPE = Thrush.SHHH;

SmartsID: TYPE = Thrush.SmartsID;

StateInConv: TYPE = Thrush.StateInConv;

nullInterfaceSpec: Thrush.InterfaceSpec = [serviceID: nullID];

uniqueSuffix: CARD ← 0;

PD: TYPE = FinchSmarts.PD;

pd: PUBLIC REF PD ← NEW[PD←[]];

info: PUBLIC FinchInfo←NIL;

Report: PROC[what: ROPE] = {

IF NOT pd.doReports THEN RETURN;

VoiceUtils.Report[what, $Finch];

};

NConcConvs: PROC[l1, l2: LIST OF ConvDesc] RETURNS [LIST OF ConvDesc] = {

IF l1=NIL THEN RETURN[l2];

FOR convs: LIST OF ConvDesc ← l1, convs.rest WHILE convs#NIL DO

IF convs.rest=NIL THEN { convs.rest←l2; RETURN[l1]; };

ENDLOOP;

ERROR;

};

DequeueConv: PROC[l1: LIST OF ConvDesc, c: ConvDesc] RETURNS [LIST OF ConvDesc] = {

IF l1=NIL THEN RETURN[l1]; -- No list

IF l1.first=c THEN RETURN[l1.rest]; -- Head of list

FOR convs: LIST OF ConvDesc ← l1, convs.rest WHILE convs.rest#NIL DO

IF convs.rest.first=c THEN { convs.rest ← convs.rest.rest; RETURN[l1]; }; -- Internal to list

ENDLOOP;

RETURN[l1]; -- Not in list

};

Supervision

Progress: PUBLIC ENTRY PROC[

shh: SHHH,

convEvent: Thrush.ConvEvent

] = {

ENABLE UNWIND => NULL; -- RestoreInvariant;

Some party has changed state in a conversation we know about (or should).

Two cases:

Our party has changed state in a conversation, whether or not we're going to deal with it (at present, LarkSmarts makes all such decisions)

Another party changed state in a conversation we know about (at present, we don't need to know that; again, LarkSmarts does all the work.) That case is filtered out in Progress, above.

It is our duty to obtain all relevant information about the call when the information becomes available, and to notify any Finch Clients.

IF convEvent.self.partyID = convEvent.other.partyID

OR convEvent.other.state >= $active -- Possibly a hack, DCS February 26, 1988

THEN [] ← NoteNewState[convEvent];

};

Substitution: PUBLIC ENTRY PROC[

shh: SHHH,

convEvent: Thrush.ConvEvent,

oldPartyID: Thrush.PartyID,

newPartyID: Thrush.PartyID

] = {

ENABLE UNWIND => NULL; -- RestoreInvariant;

One party has replaced another (they were or are now in a poacher/poachee relationship) in this conversation, so we need to update our information about the conversation. Same as Progress, except that we clear any indication that we know anything about the present state before noting the new state.

If this notice indicates that our own party is the oldPartyID, we should find a way to inform our ReportConversationState clients that we are no longer involved in this conversation. We should also pull the conv. from our active list. This happens when the same user logs in and runs Finch somewhere else, or when our Finch bombs out in the middle of a conversation.

cDesc: ConvDesc = GetConv[convEvent.self.convID, FALSE];

IF cDesc#NIL THEN cDesc.numParties ← 0; -- This will force the information update.

[] ← NoteNewState[ convEvent ];

};

ReportAction: PUBLIC ENTRY PROC[

shh: SHHH,

report: Thrush.ActionReport

] = {

ENABLE UNWIND => NULL;

ReportRequestState[GetConv[report.self.convID], report];

BROADCAST info.stateChange; -- Sometimes callers wait (Ugh!)}

};

CheckIn: PUBLIC ENTRY PROC[

shh: Thrush.SHHH,

credentials: Thrush.Credentials,

voicePath: BOOL,

reason: Thrush.Reason,

remark: ROPE,

nextScheduledCheck: INT

] = {

ENABLE UNWIND => NULL;

localRemark: ROPE←NIL;

connected: BOOL ← TRUE;

enabled: BOOL ← info.enabled;

info.nextScheduledCheck ← nextScheduledCheck;

SELECT reason FROM

$goodbye => {

enabled ← connected ← FALSE;

localRemark ← "Permanent disconnect requested by server";

};

$trylater => {

localRemark ← "Temporary disconnect requested by server";

connected ← FALSE;

};

$welcome, $hello => connected ← TRUE;

ENDCASE;

[]𡤏inchSmarts.RecordSystemStateFromSmartsReport[

remark: localRemark, connected: connected, enabled: enabled, voicePath: voicePath, remoteRemark: remark];

NOTIFY info.pollCondition;

};

Poke: PUBLIC ENTRY PROC = {

ENABLE UNWIND => NULL;

IF info#NIL THEN NOTIFY info.pollCondition; };

Polling loop will awaken immediately and if necessary (and not inhibited) try to reconnect.

LimitSignalling: ENTRY PROC [cDesc: ConvDesc, signalState: StateInConv] ~ TRUSTED {

We have entered an unstable state, which should not be allowed to persist too long before we hang up and free our resources. "Too long" is determined by pd.timeoutInitiating.

If we ever decide to deal with $initiating states on our own, we may have to accommodate thaat here, too.

ENABLE UNWIND => NULL;

c: CONDITION;

Process.SetTimeout[@c, Process.SecondsToTicks[pd.timeoutInitiating]];

WAIT c;

IF cDesc.situation.self.state # signalState THEN RETURN;

[]←Request[cDesc, $failed, $noAnswer,

IF signalState=$notified THEN "Other party failed to respond to call."

ELSE "We did not respond to call. Notify LarkSupport."];

};

Client Functions

CallInfo: TYPE = REF CallInfoBody; -- needed because MBQueue requires a REF

CallInfoBody: TYPE = RECORD [

convID: Thrush.ConversationID,

calledPartyID: Thrush.PartyID←nullID,

reason: Thrush.Reason←NIL,

comment: ROPE←NIL

];

DisconnectCall: PUBLIC ENTRY PROC[

convID: Thrush.ConversationID,

reason: Thrush.Reason ← $terminating,

comment: ROPE←NIL,

newState: StateInConv ← $idle] = {

ENABLE UNWIND => NULL; -- RestoreInvariant;

cDesc: ConvDesc; state: StateInConv;

IF NOT(([,cDesc, state]𡤏inchOn[convID]).on) THEN RETURN;

SELECT state FROM

$idle, $neverWas => {

ReportConversationState[$convNotActive, NIL, "No conversation to disconnect"];

};

ENDCASE => []←Request[cDesc, newState, reason, comment];

};

AnswerCall: PUBLIC ENTRY PROC[convID: Thrush.ConversationID] = {

ENABLE UNWIND => NULL; -- RestoreInvariant;

cDesc: ConvDesc; state: StateInConv;

IF NOT (([,cDesc, state]𡤏inchOn[convID]).on) THEN RETURN;

SELECT state FROM $ringing, $notified => []←Request[cDesc, $active]; ENDCASE;

};

PlaceCall: PUBLIC ENTRY PROC [

convID: Thrush.ConversationID←nullConvID,

rName: ROPE, -- rName or description

number: ROPE, -- telephone number, if present

useNumber: BOOL←FALSE

] = {

ENABLE UNWIND=>NULL; -- RestoreInvariant;

PlaceCallInt[convID, rName, number, useNumber];

};

PlaceCallInt: INTERNAL PROC [

convID: Thrush.ConversationID←nullConvID,

rName: ROPE, -- rName or description

number: ROPE, -- telephone number, if present

useNumber: BOOL←FALSE,

convAttributes: ThParty.Attributes ← NIL,

partyAttributes: ThParty.Attributes ← NIL

] = {

calledPartyID: PartyID;

nb: NB;

reason: Thrush.Reason ← $notFound;

comment: Rope.ROPE ← NIL;

IF ~useNumber THEN {

[nb, calledPartyID] ←ThParty.GetParty[shh:info.shh, partyID:info.partyID, rName:rName];

SELECT nb FROM

$noSuchParty2, $noIdentSupplied => useNumber ← TRUE;

$serverDown, $notEnabled, $noSuchParty => RETURN; -- Futile

ENDCASE;

};

IF useNumber AND number.Length[]>0 THEN

[nb, calledPartyID] ← ThParty.GetPartyFromNumber[

shh: info.shh, partyID: info.partyID, phoneNumber: number, description: rName];

SELECT nb FROM

$success => reason ← NIL; -- reason: NIL, comment: NIL

$noSuchParty2 => NULL; -- reason: $notFound, comment: NIL

$narcissism => comment ← "Attempt to call self rejected on philosophical grounds";

ENDCASE => { ReportConversationState[nb, NIL, NIL]; RETURN; };

[--nb, cDesc--]𡤌onnect[calledPartyID, convID, reason, comment, convAttributes, partyAttributes];

};

lowPriority: ThParty.Attributes ← LIST[[$Priority, "300"]];

Join: PUBLIC ENTRY PROC[convName: Rope.ROPE]

RETURNS[nb: Thrush.NB←$noSuchConv] = {

ENABLE UNWIND => NULL;

conversationInfo: ThParty.ConversationInfo;

cDesc: FinchSmarts.ConvDesc;

rName: Rope.ROPE;

[nb, conversationInfo] ← ThParty.GetConversationFromName[

shhh: info.shh, partyID: info.partyID, name: convName];

IF nb=$success AND conversationInfo.numIdle >= conversationInfo.numParties THEN

nb ← $noSuchConv;

SELECT nb FROM

$success => NULL;

$noSuchConv => {

rName ← NameDB.GetAttribute[

rName: convName, attribute: $rname, key: $conversationname];

IF rName=NIL THEN RETURN;

nb ← $unknown;

PlaceCallInt[rName: rName, number: NIL, partyAttributes: lowPriority];

nb ← $success;

RETURN;

};

ENDCASE => RETURN;

cDesc ← GetConv[convID: conversationInfo.convID, createOK: TRUE];

nb ← Request[cDesc, $active, $join, "Join conversation in progress", NIL, lowPriority];

IF nb=$stateMismatch THEN -- Try at most twice

nb ← Request[cDesc, $active, $join, "Join conversation in progress", NIL, lowPriority];

};

Feep: PUBLIC ENTRY PROC[convID: ConversationID, feepString: ROPE] = {

ENABLE UNWIND => NULL;

cDesc: ConvDesc;

nb: Thrush.NB←$success; {

state: StateInConv;

IF NOT(([,cDesc, state]𡤏inchOn[convID]).on) OR state#$active THEN nb ← $convNotActive;

IF nb=$success AND cDesc.feepInterface=NIL THEN {

[nb, cDesc.feepInterfaceSpec] ← ObtainServiceInterface[NIL, "LarkFeep", cDesc];

IF nb=$success AND cDesc.feepShhh = NIL THEN

[cDesc.feepInterface, cDesc.feepShhh] ← LarkFeepSunImport.ImportInterface[

instance: cDesc.feepInterfaceSpec.interfaceName.instance];

Really need better generic way to avoid duplicating work and stranding connections, here!

};

IF nb=$success THEN nb ← cDesc.feepInterface.clientStubFeep[

interface: cDesc.feepInterface, shhh: cDesc.feepShhh,

serviceID: cDesc.feepInterfaceSpec.serviceID,

convID: cDesc.situation.self.convID, requestingParty: cDesc.situation.self.partyID,

number: feepString, noisy: UserProfile.Boolean["Finch.NoisyFeep", TRUE], on: 100, off: 80

];

};

IF nb # $success THEN VoiceUtils.Report["Sorry, was not able to `feep'.", $Finch];

};

ObtainNumbersForRName: PUBLIC PROC[rName: ROPE]

RETURNS [fullRName: ROPE, number: ROPE, homeNumber: ROPE] = {

[fullRName, number, homeNumber] ←

ThParty.GetNumbersForRName[shh: info.shh, rName: rName];

};

CurrentRName: PUBLIC PROC RETURNS [rName: ROPE] = {

RETURN[IF info#NIL THEN info.myRName ELSE NIL];

};

CurrentConversations: PUBLIC PROC RETURNS [conversations: LIST OF ConvDesc] = {

RETURN[IF info#NIL THEN info.conversations ELSE NIL];

};

IdentifyVisitor: PUBLIC ENTRY PROC [visitor, password: Rope.ROPE, complain: BOOL ← TRUE] RETURNS [nb: NB] ~ {

ENABLE UNWIND => NULL;

guestPartyID: PartyID;

guestPassKey: RPC.EncryptionKey ← VoiceUtils.CurrentPasskey[password];

guest: Rope.ROPE ← VoiceUtils.Registrize[visitor];

IF Rope.Equal[info.myRName, guest, FALSE] THEN {

cancelling visiting at home via "Visit self"

ReleaseVisitorSelf[]; RETURN

};

[nb, guestPartyID] ←ThParty.GetParty[shh:info.shh, partyID:info.partyID, rName:guest];

IF nb=$success THEN

nb ← ThParty.Visit[shh: info.shh, hostPartyID: info.partyID, guestPartyID: guestPartyID, guestPassword: guestPassKey];

SELECT nb FROM

$success => VoiceUtils.ReportFR["%s visiting %s -- %s calls will ring in both offices", $Finch, NIL, IO.rope[guest], IO.rope[info.myRName], IO.rope[guest]];

$passwordNotValid => IF complain THEN VoiceUtils.ReportFR[
"Invalid password for %s", $Finch, NIL, IO.rope[guest]];

$visitingIllegal => Problem[
"Visitor and/or visitee not suitable for visiting (possibly missing Lark?)"];

$noSuchParty2 => VoiceUtils.ReportFR[
"Couldn't identify visitor %s", $Finch, NIL, IO.rope[guest]];

$noSuchParty => VoiceUtils.ReportFR["Couldn't identify visitee %s", $Finch, NIL, IO.rope[info.myRName]]; -- should never happen

ENDCASE => Problem["Server communication problem", nb];

};

ReleaseVisitor: PUBLIC ENTRY PROC [visitor, password: Rope.ROPE] ~ {

ENABLE UNWIND => NULL;

nb: NB;

guestPartyID: PartyID;

guestPassword: RPC.EncryptionKey ← VoiceUtils.CurrentPasskey[password];

IF visitor.Length[]=0 THEN { -- assume cancelling visiting at home via "Unvisit"

ReleaseVisitorSelf[]; RETURN

};

visitor ← VoiceUtils.Registrize[visitor];

IF Rope.Equal[info.myRName, visitor, FALSE] THEN {

cancelling visiting at home via "Unvisit self"

ReleaseVisitorSelf[]; RETURN

};

[nb, guestPartyID] ←ThParty.GetParty[shh:info.shh, partyID:info.partyID, rName: visitor];

If ThParty.Unvisit really cared about passwords (which it does not currently), we would have to keep passwords of relevant visitors, probably in the FinchInfo record.

IF nb=$noSuchParty2 THEN VoiceUtils.ReportFR[
"Couldn't identify visitor %s", $Finch, NIL, IO.rope[visitor]];

Need to swap the nb codes in ThPartyInitImpl

IF nb = $success THEN {

hostPartyID: PartyID;

[visitee: hostPartyID] ← ThParty.DescribeParty[partyID: guestPartyID, nameReq: $none];

nb ← IF hostPartyID=info.partyID

THEN ThParty.Unvisit[shh: info.shh, hostPartyID: hostPartyID,

guestPartyID: guestPartyID, guestPassword: guestPassword]

ELSE $noSuchVisiting;

};

SELECT nb FROM

$success => VoiceUtils.ReportFR["Visiting cancelled for %s", $Finch, NIL, IO.rope[visitor]];

$noSuchVisiting => VoiceUtils.ReportFR[
"%s was not visiting here", $Finch, NIL, IO.rope[visitor]];

$noSuchParty => VoiceUtils.ReportFR[
"Couldn't identify visitor %s", $Finch, NIL, IO.rope[visitor]];

$noSuchParty2 => VoiceUtils.ReportFR["Couldn't identify visitee %s", $Finch, NIL, IO.rope[info.myRName]]; -- should never happen

ENDCASE => Problem["Server communication problem", nb];

};

ReleaseVisitorSelf: INTERNAL PROC ~ {

nb: NB ← $noSuchVisiting;

IF info.partyID # nullID THEN

nb ← ThParty.UnvisitSelf[shh: info.shh, guestPartyID: info.partyID];

SELECT nb FROM

$success => VoiceUtils.ReportFR[

"Visiting cancelled for %s -- welcome home", $Finch, NIL, IO.rope[info.myRName]];

$noSuchVisiting => VoiceUtils.ReportFR[
"%s was not visiting anywhere", $Finch, NIL, IO.rope[info.myRName]];

$noSuchParty => VoiceUtils.ReportFR["Couldn't identify visitor %s", $Finch, NIL, IO.rope[info.myRName]]; -- should never happen

ENDCASE => Problem["Server communication problem", nb];

};

ServiceConnect: PUBLIC ENTRY PROC[

serviceName: ROPE,

convID: ConversationID←nullConvID,

createOK: BOOL←TRUE, addOK: BOOL←FALSE ] RETURNS [

nb: NB←$success,

cDesc: ConvDesc←NIL ] = { ENABLE UNWIND=>NULL;

state: StateInConv ← $idle;

calledPartyID: PartyID;

cCode: ConvCode;

backgroundAttributes: ThParty.Attributes ← IF backgrounding THEN lowPriority ELSE NIL;

IF NOT (([,cDesc, state]𡤏inchOn[convID]).on) THEN RETURN[nb: $finchNotRunning];

IF cDesc#NIL AND cDesc.situation.self.state>Thrush.notReallyInConv THEN RETURN;

[cCode, cDesc] ← GetActiveConversation[serviceName,addOK];

SELECT cCode FROM

$ok => { nb ← WaitForActive[cDesc, FALSE]; RETURN; };

$hld => {

nb ← Request[cDesc, $active];

IF nb=$success THEN nb ← WaitForActive[cDesc, FALSE];

RETURN;

};

$bzy => RETURN[$convStillActive, NIL];

$idl, $res, $addOK => IF ~createOK THEN RETURN[$noSuchConv, NIL];

ENDCASE => ERROR;

IF cDesc#NIL THEN { state← cDesc.situation.self.state; convID← cDesc.situation.self.convID; };

IF serviceName = NIL THEN calledPartyID ← nullID

ELSE [nb, calledPartyID] ← ThParty.GetParty[

shh: info.shh, partyID: info.partyID, rName: serviceName, type: $service];

IF nb=$success THEN [nb, cDesc] ← Connect[calledPartyID: calledPartyID, convID: convID,

partyAttributes: backgroundAttributes, addOK: addOK];

IF nb=$success AND serviceName#NIL THEN nb ← WaitForActive[cDesc, TRUE];

};

ConvCode: TYPE = { ok, addOK, res, hld, bzy, idl };

GetActiveConversation: INTERNAL PROC[serviceName: ROPE←NIL, addOK: BOOL←FALSE]

RETURNS[convCode: ConvCode ← $idl, cDesc: ConvDesc←NIL] = {

Find, in this order:

$ok) a non-idle conversation that's already established to the specified service.

$addOK) an active conversation that does not include the specified service (addOK only)

$res) a conversation in state $reserved

$hld) an established converation is on hold and waiting.

$bzy) an established conversation that doesn't satisfy the above criteria

$idl) no active conversations exist.

IF serviceName=NIL THEN RETURN; -- Can't validate

FOR convs: LIST OF ConvDesc ← info.conversations, convs.rest WHILE convs#NIL DO

possibleCDesc: ConvDesc ← NARROW[convs.first];

pInfo: ThParty.PartyInfo ← possibleCDesc.partyInfo;

possibleState: StateInConv ← possibleCDesc.situation.self.state;

SELECT possibleState FROM

$reserved => {convCode ← $res; cDesc ← possibleCDesc; LOOP;};

Reserved takes precedence over held, but all others take precedence over both

$inactive => {

IF convCode=$idl THEN { convCode ← $hld; cDesc ← possibleCDesc; }; LOOP;};

$initiating, $ringback, $active => NULL;

ENDCASE => LOOP;

We've found a sufficiently advanced conv. to disavow any others.

IF pInfo#NIL THEN FOR ix: NAT IN [1..pInfo.conversationInfo.numParties] DO

IF ix#pInfo.ixSelf AND pInfo[ix].type=$service AND

Rope.IsPrefix[serviceName, pInfo[ix].name, FALSE] THEN RETURN[$ok, possibleCDesc];

ENDLOOP; -- There's still presumably at most one active conversation

RETURN[

IF addOK AND possibleCDesc.situation.self.state=$active THEN $addOK ELSE $bzy,

possibleCDesc];

ENDLOOP;

};

ObtainServiceInterface: PUBLIC PROC[

serviceName: ROPE,

interfaceName: ROPE,

cDesc: ConvDesc←NIL

] RETURNS [

nb: NB←$success,

interfaceSpec: Thrush.InterfaceSpec

] = {

partyID: Thrush.PartyID←Thrush.nullID;

credentials: Thrush.Credentials;

IF cDesc#NIL THEN {

pInfo: ThParty.PartyInfo ← cDesc.partyInfo;

credentials ← cDesc.situation.self;

IF pInfo#NIL THEN FOR ix: NAT IN [1..pInfo.conversationInfo.numParties] DO

IF ix # pInfo.ixSelf AND (

serviceName=NIL OR (

pInfo[ix].type = $service AND pInfo[ix].state >= $active AND

Rope.IsPrefix[serviceName, pInfo[ix].name, FALSE] ) ) THEN {

partyID ← pInfo[ix].partyID;

EXIT;

};

ENDLOOP;

}

ELSE IF serviceName = NIL THEN partyID ← info.partyID -- get from self!

ELSE { -- want interface only

credentials ← [info.partyID, info.smartsID];

[nb, partyID] ←ThParty.GetParty[

shh: info.shh, partyID: info.partyID, rName: serviceName, type: $service];

IF nb#$success THEN RETURN;

};

IF partyID = Thrush.nullID THEN

RETURN[nb: $noSuchParty2, interfaceSpec: nullInterfaceSpec];

[nb, interfaceSpec] ←

ThParty.LookupServiceInterface[info.shh, credentials, partyID, interfaceName];

};

anyone: LIST OF ROPE ← LIST["*"];

announcement: ThParty.Attributes ← LIST[[$subject, "Announcement"]];

mediumPriority: ThParty.Attributes ← LIST[[$Priority, "400"]];

Less than live calls, but more than services.

Announce: ENTRY PROC [rNames: LIST OF ROPE] ~ {

ENABLE UNWIND=>NULL; -- RestoreInvariant;

[] ← AnnounceInt[rNames];

};

AnnounceInt: INTERNAL PROC [rNames: LIST OF ROPE] RETURNS [nb: NB←$success, cDesc: ConvDesc←NIL] ~ {

count: INT ← 0;

state: StateInConv;

convID: ConversationID←nullConvID;

convEvent: Thrush.ConvEvent;

IF ~(([,cDesc, state]𡤏inchOn[convID]).on) THEN { nb ← $notEnabled; RETURN; };

IF cDesc = NIL THEN [cDesc, state] ← GetCurrentConv[];

If there's an existing proto-conversation, use it...

SELECT state FROM

$idle => {

[nb, convEvent] ← ThParty.CreateConversation[

shhh: info.shh,

credentials: [partyID: info.partyID, smartsID: info.smartsID]

];

IF nb = $success THEN {

pInfo: ThParty.PartyInfo;

cDesc ← NoteNewState[convEvent];

pInfo ← cDesc.partyInfo;

IF pInfo=NIL OR ~pInfo[pInfo.ixSelf].voicePath THEN {

[] ← Request[cDesc, $failed, $noVoicePath, "Your Etherphone is not running"];

RETURN[$noVoicePath, cDesc];

};

$reserved, $parsing => nb ← Request[cDesc, $initiating];

ENDCASE => {

ReportConversationState[$convStillActive, NIL, "Conversation already in progress"];

RETURN;

};

IF nb # $success THEN RETURN;

cDesc.originatorRecorded ← TRUE;

nb ← ThParty.RegisterConversation[shhh: info.shh, credentials: cDesc.situation.self,
name: "Announcement", convAttributes: announcement, accessList: anyone];

VoiceUtils.Report["Notifying listeners...", $Finch];

FOR names: LIST OF ROPE ← rNames, names.rest WHILE names#NIL DO

calledPartyID: PartyID;

partyType: Thrush.PartyType;

IF Rope.Equal[names.first, info.myRName, FALSE] THEN LOOP; -- Don't call self

This isn't quite good enough, because person A might log in at person B's machine and try to announce to person B.

[nb, calledPartyID] ←ThParty.GetParty[shh:info.shh, partyID:info.partyID, rName:names.first];

SELECT nb FROM

$serverDown, $notEnabled => RETURN; -- Futile

$noSuchParty2, $noIdentSupplied, $noSuchParty => LOOP;

ENDCASE;

[nb: nb, type: partyType] ← ThParty.DescribeParty[calledPartyID, $current];

IF partyType=$trunk THEN LOOP;

not an Etherphone user; can't participate in a multicast call

nb←ThParty.Alert[shhh: info.shh,

credentials: cDesc.situation.self, calledPartyID: calledPartyID, partyAttributes: mediumPriority];

SELECT nb FROM

$success => count ← count + 1;

$stateMismatch => {

nb←Request[cDesc, $failed, $error, "Conversation already in progress"];

Some smarts don't do this. They probably should.

RETURN;

};

$narcissism => NULL; -- Should never happen ???see above???

ENDCASE => {Problem["Server communication problem", nb]; RETURN;}

Do something interesting — see other smarts for more confusion

ENDLOOP;

nb ← WaitForActive[cDesc, FALSE];

IF nb=$success AND count > 0 THEN

VoiceUtils.ReportFR["%g parties contacted -- Please begin speaking", $Finch, NIL, IO.int[count]]

ELSE

VoiceUtils.Report["No listeners found", $Finch, NIL];

};

Utilities

GetConv: INTERNAL PROC[convID: ConversationID, createOK: BOOL←FALSE]

RETURNS [ cDesc: ConvDesc←NIL ] = --INLINE-- {

cL: LIST OF ConvDesc;

IF convID#nullConvID THEN

FOR convs: LIST OF ConvDesc ← info.conversations, convs.rest WHILE convs#NIL DO

cDesc ← convs.first;

IF cDesc.situation.self.convID = convID THEN RETURN;

ENDLOOP;

cDesc ← NIL;

IF ~createOK THEN RETURN;

New conversation

cDesc ← NEW[FinchSmarts.ConvDescBody←[

situation: [ self: [ convID: convID, smartsID: info.smartsID, partyID: info.partyID ]]]];

cL ← LIST[cDesc];

info.conversations ← NConcConvs[info.conversations, cL];

};

FinchOn: INTERNAL PROC[convID: ConversationID←nullConvID] RETURNS [

on: BOOL←FALSE, cDesc: ConvDesc←NIL, state: StateInConv←$idle] = {

IF info=NIL OR ~info.enabled THEN {

VoiceUtils.Report["Your Finch is not running", $Finch]; RETURN; };

on←TRUE;

IF convID=nullConvID THEN RETURN;

cDesc ← GetConv[convID, FALSE];

IF cDesc#NIL THEN state�sc.situation.self.state;

};

NoteNewState: INTERNAL PROC[convEvent: Thrush.ConvEvent] RETURNS[cDesc: ConvDesc]= {

cInfo: ThParty.ConversationInfo;

pInfo: ThParty.PartyInfo;

nb: NB;

timeAdjustment: INT;

prevState, currState: StateInConv;

cDesc ← GetConv[convEvent.self.convID, TRUE];

prevState ← cDesc.situation.self.state;

cDesc.situation ← convEvent^;

[nb, cInfo] ← ThParty.GetConversationInfo[shh: info.shh, convID: convEvent.self.convID];

Now gather up additional information that we might not know yet:

Who started this?

Who the other party(s) is (are)

currState ← cDesc.situation.self.state;

SELECT TRUE FROM

nb # $success => NULL; -- Problem["Can't obtain conversation information"];

This will occur during shutdown when Substitute is reporting removal from conversations. Better to avoid complaint and use the information at hand.

currState#prevState, cDesc.numParties#cInfo.numParties,
cDesc.numActive#cInfo.numActive, cDesc.numIdle#cInfo.numIdle => {

State information guaranteed correct only as of last time one of these numbers changed.

cDesc.subject ← FetchAttribute[cInfo.convAttributes, $subject].value;

timeAdjustment ← BasicTime.Period[from: convEvent.time, to: BasicTime.Now[]];

cDesc.startTime ← BasicTime.Update[cInfo.startTime, timeAdjustment];

cDesc.numParties ← cInfo.numParties;

cDesc.numActive ← cInfo.numActive;

cDesc.numIdle ← cInfo.numIdle;

[nb, pInfo] ←

ThParty.GetPartyInfo[shh: info.shh, credentials: cDesc.situation.self,

nameReq: $description, allParties: TRUE];

IF nb#$success THEN NULL -- Problem["Can't obtain conversation information", nb]

ELSE {

ixOriginator: NAT ← pInfo.ixOriginator;

cDesc.partyInfo ← pInfo;

IF ixOriginator#ThParty.nullIx AND ixOriginator # pInfo.ixSelf AND

pInfo[ixOriginator].type=$trunk THEN

pInfo[ixOriginator].intendedName ← "outside line";

};

ENDCASE;

SELECT currState FROM

$idle, $neverWas => info.conversations ← DequeueConv[info.conversations, cDesc];

$initiating => TRUSTED { Process.Detach[FORK LimitSignalling[cDesc, $initiating]]; };

$notified => SELECT filtering FROM -- Needs tests for calls already in progress.

1 => []←Request[cDesc, $idle, $notImportantEnough, "This is a test"];

2 => []←Request[cDesc, $ringing];

3 => []←Request[cDesc, $active, $whatever, "Hot line!"];

ENDCASE => TRUSTED { Process.Detach[FORK LimitSignalling[cDesc, $notified]]; };

ENDCASE;

IF currState#inactive AND cDesc.ultimateState<currState THEN cDesc.ultimateState ← currState;

Probably Thrush.StateInConv should order conversation states st inactive < active.

ReportConversationState[$success, cDesc, NIL];

If we've been called due to a Substitution that's kicking us out (cf Subst.), we should find a way to inform our ReportConversationState clients that we are no longer involved in this conversation. We should also do a Dequeue as above.

BROADCAST info.stateChange;

};

maxJoinTries: INT ← 3;

Request: INTERNAL PROC[

cDesc: ConvDesc,

state: StateInConv,

reason: Thrush.Reason←NIL,

comment: ROPE←NIL,

convAttributes: ThParty.Attributes←NIL,

partyAttributes: ThParty.Attributes←NIL

]

RETURNS [nb: NB] = {

convEvent: Thrush.ConvEvent;

pInfo: ThParty.PartyInfo ← cDesc.partyInfo;

reportToAll: BOOL = SELECT state FROM

$idle, $failed, $active, $inactive, $ringing => TRUE, ENDCASE=>FALSE;

IF state=$failed AND (pInfo = NIL OR ~pInfo[pInfo.ixSelf].voicePath) THEN state ← $idle;

[nb, convEvent] ←

ThParty.Advance[shhh: info.shh, credentials: cDesc.situation.self, state: state,

reportToAll: reportToAll, reason: reason, comment: comment, convAttributes: convAttributes, partyAttributes: partyAttributes];

SELECT nb FROM

$success => []←NoteNewState[convEvent];

$stateMismatch => {

cDesc←NoteNewState[convEvent];

IF cDesc.situation.self.state = state THEN nb ← $success

if we're in the state we wanted, ignore stateMismatch

ELSE IF state=$idle AND cDesc.situation.self.state # $idle THEN LOOP;

};

ENDCASE =>

ReportConversationState[nb, cDesc, "Telephone server action failed"];

Real confused about Problem (typeout only) reporting vs. client reporting. The responsibilities are unconvincingly distributed among Smarts and client.

EXIT;

ENDLOOP;

};

Connect: INTERNAL PROC [calledPartyID: PartyID, convID: ConversationID←nullConvID, reason: Thrush.Reason ← NIL, comment: ROPE←NIL, convAttributes: ThParty.Attributes ← NIL, partyAttributes: ThParty.Attributes ← NIL, addOK: BOOL←FALSE]

RETURNS [ nb: NB←$success, cDesc: ConvDesc←NIL ] = {

If there's a reason, the connect request's only purpose is to record an error condition, audibly as well as visually. This requires the creation of a conversation, then its immediate termination.

state: StateInConv;

newState: StateInConv = SELECT TRUE FROM

reason#NIL => $failed,

calledPartyID = nullID => $parsing, -- temp until can debug inactive stuff.

ENDCASE => $initiating;

convEvent: Thrush.ConvEvent;

IF ~(([,cDesc, state]𡤏inchOn[convID]).on) THEN { nb ← $notEnabled; RETURN; };

SELECT state FROM

$idle => {

[nb, convEvent] ← ThParty.CreateConversation[

shhh: info.shh,

credentials: [partyID: info.partyID, smartsID: info.smartsID],

state: newState,

reason: reason,

comment: comment,

convAttributes: convAttributes,

partyAttributes: partyAttributes

];

IF nb = $success THEN {

pInfo: ThParty.PartyInfo;

cDesc ← NoteNewState[convEvent];

pInfo ← cDesc.partyInfo;

IF pInfo=NIL OR ~pInfo[pInfo.ixSelf].voicePath THEN {

[] ← Request[cDesc, $failed, $noVoicePath, "Your Etherphone is not running"];

RETURN[$noVoicePath, cDesc];

};

$reserved, $parsing => nb ← Request[cDesc, newState, reason, comment, convAttributes, partyAttributes];

$active => IF ~addOK THEN {

ReportConversationState[$convStillActive, NIL, "Conversation already in progress"];

RETURN;

};

ENDCASE => {

ReportConversationState[$convStillActive, NIL, "Conversation already in progress"];

RETURN;

};

IF nb # $success OR newState=$failed THEN RETURN;

cDesc.originatorRecorded ← TRUE;

IF newState # $initiating THEN RETURN;

nb←ThParty.Alert[shhh: info.shh,

credentials: cDesc.situation.self, calledPartyID: calledPartyID];

SELECT nb FROM

$success => NULL;

$stateMismatch => {

nb←Request[cDesc, $failed, $error, "Conversation already in progress"];

Some smarts don't do this. They probably should.

RETURN;

};

$narcissism => {

nb←Request[cDesc, $failed, $notFound, "Attempt to call self rejected on philosophical grounds"];

RETURN;

};

ENDCASE => Problem["Server communication problem", nb];

Do something interesting — see other smarts for more confusion

};

WaitForActive: INTERNAL PROC[cDesc: ConvDesc, demandNewParty: BOOL←FALSE]

RETURNS [nb: NB←$success] = {

For use in Recording, and so on, where client needs to wait for setup. demandNewParty asserts that we have invited the recording service to join us, and we need to wait until that has happened. February 26, 1988 DCS

numParties: NAT ← cDesc.numParties;

FOR i: NAT IN [0..pd.waitsForConnect) DO

SELECT cDesc.situation.self.state FROM

$active => IF ~demandNewParty OR cDesc.numParties > numParties THEN RETURN;

$failed => EXIT;

ENDCASE;

TRUSTED{Process.SetTimeout[@info.stateChange,Process.SecondsToTicks[pd.jayTimeout]];};

WAIT info.stateChange;

SELECT cDesc.situation.self.state FROM

$idle, $neverWas => EXIT; -- something wrong.

ENDCASE;

ENDLOOP;

nb←Request[cDesc, $failed, $error, "Finch failed to connect to voice service."];

IF nb=$success THEN nb←$timedOut;

};

Problem: PUBLIC PROC[remark: ROPE←NIL, nb: NB←NIL] = {

IF nb=NIL THEN VoiceUtils.Problem[remark, $Finch]

ELSE VoiceUtils.ProblemFR["%g, reason: %g", $Finch, NIL, rope[remark], atom[nb]];

};

FetchAttribute: PUBLIC PROC[

attributes: ThParty.Attributes, attribute: ATOM, default: ROPE←NIL]

RETURNS [value: ROPE, valueLoc: ThParty.Attributes←NIL] = {

value ← default;

FOR aL: ThParty.Attributes ← attributes, aL.rest WHILE aL#NIL DO

IF aL.first.type = attribute THEN RETURN[aL.first.value, aL]; ENDLOOP;

};

GetCurrentConv: INTERNAL PROC RETURNS [ cDesc: ConvDesc←NIL, state: Thrush.StateInConv ] = --INLINE-- {

Finds an existing proto-conversation (i.e., state = $reserved or $parsing) that is NOT a service conversation.

FOR convs: LIST OF ConvDesc ← info.conversations, convs.rest WHILE convs#NIL DO

ok: BOOL ← TRUE;

cDesc ← convs.first;

state ← cDesc.situation.self.state;

SELECT state FROM

$reserved, $parsing => {

pInfo: ThParty.PartyInfo ← cDesc.partyInfo;

FOR ix: NAT IN [1..pInfo.conversationInfo.numParties] DO

IF ix#pInfo.ixSelf AND pInfo[ix].type=$service THEN {

ok ← FALSE;

EXIT;

};

ENDLOOP;

IF ok THEN RETURN;

};

ENDCASE;

ENDLOOP;

cDesc ← NIL;

state ← $idle;

};

State reports, other than system state (look in FinchRegisterImpl for that)

Reports of all kinds are serialized and decoupled from their issuers. Perhaps this is not entirely necessary, but it's hard to prove otherwise. The problems are: (a) There can otherwise be deadlocks when A.entry1 calls B.p, and B.p issues a report proc that turns out to be A.entry2. (b) Reports can be issued from many places and processes, and it appears they should be seen in the order issued, wherever they come from. Action reports may not qualify, except that they should not proceed out of synch of the other two kinds, which do.

ReportConversationState: PUBLIC PROC [nb: NB, cDesc: ConvDesc, remark: Rope.ROPE] ~ {

IF info=NIL THEN RETURN;

pd.requests.QueueClientAction[ReallyReportConversationState,

NEW[CSBody ← [nb, cDesc, remark]]];

};

CS: TYPE = REF CSBody;

CSBody: TYPE = RECORD[nb: NB, cDesc: ConvDesc, remark: Rope.ROPE];

ReallyReportConversationState: PROC[r: REF] = {

cS: CS ← NARROW[r];

reportProcsTable: RedBlackTree.Table ← NARROW[Atom.GetProp[$ReportProcs, $rpTable]];

EachRCS: RedBlackTree.EachNode = {

procs: FinchSmarts.ReportProcs ← NARROW[data];

IF procs.reportConversationState#NIL THEN

procs.reportConversationState[cS.nb, cS.cDesc, cS.remark];

};

IF reportProcsTable#NIL THEN

EnumerateIncreasing[reportProcsTable, EachRCS];

};

ReportRequestState: PROC [cDesc: ConvDesc, actionReport: Thrush.ActionReport] ~ {

pd.requests.QueueClientAction[ReallyReportRequestState,

NEW[RSBody ← [cDesc, actionReport]]];

};

RS: TYPE = REF RSBody;

RSBody: TYPE = RECORD[cDesc: ConvDesc, actionReport: Thrush.ActionReport];

ReallyReportRequestState: PROC[r: REF] = {

rS: RS ← NARROW[r];

reportProcsTable: RedBlackTree.Table ← NARROW[Atom.GetProp[$ReportProcs, $rpTable]];

actionRequest: REF←NIL;

EachRRS: RedBlackTree.EachNode = {

procs: FinchSmarts.ReportProcs ← NARROW[data];

IF procs.reportRequestState#NIL THEN

actionRequest ← procs.reportRequestState[rS.cDesc, rS.actionReport, actionRequest];

};

IF reportProcsTable#NIL THEN

EnumerateIncreasing[reportProcsTable, EachRRS];

};

EnumerateIncreasing: PUBLIC PROC [self: RedBlackTree.Table, procToApply: RedBlackTree.EachNode] = {

PList: TYPE = RECORD[s: SEQUENCE m: NAT OF FinchSmarts.ReportProcs];

pList: REF PList ← NEW[PList[20]];

index: NAT ← 0;

GetEm: RedBlackTree.EachNode = {

pList[index] ← NARROW[data];

index ← index+1;

IF index=20 THEN ERROR;

};

RedBlackTree.EnumerateIncreasing[self, GetEm];

FOR doIndex: NAT IN [0..index) DO

IF procToApply[pList[doIndex]] THEN EXIT;

ENDLOOP;

};

Debugging nonsense

SetFiltering: PROC[which: INT, deferAnswer: ROPE← "true"]

RETURNS [didIt: ATOM←NIL, message: Rope.ROPE←NIL] ← {

ENABLE NameDB.Error => {didIt ← $Failure; message←"Database access failure"; CONTINUE; };

filtering ← which;

NameDB.SetAttribute[VoiceUtils.CurrentRName[], $deferanswer, deferAnswer];

};

filtering: INT𡤀

backgrounding: BOOL←FALSE;

FilterResetCmd: Commander.CommandProc = TRUSTED {

[result, msg] ← SetFiltering[0, "false"];

};

FilterZeroCmd: Commander.CommandProc = TRUSTED {

[result, msg] ← SetFiltering[0];

};

BackgroundCmd: Commander.CommandProc = TRUSTED {

[result, msg] ← SetFiltering[0];

backgrounding ← TRUE;

};

NoBackgroundCmd: Commander.CommandProc = TRUSTED {

[result, msg] ← SetFiltering[0, "false"];

backgrounding ← FALSE;

};

FilterOneCmd: Commander.CommandProc = TRUSTED {

[result, msg] ← SetFiltering[1];

};

FilterTwoCmd: Commander.CommandProc = TRUSTED {

[result, msg] ← SetFiltering[2];

};

FilterThreeCmd: Commander.CommandProc = TRUSTED {

[result, msg] ← SetFiltering[3];

};

InitFiltering: PROC = {

filterMsg: ROPE;

[message: filterMsg] ← SetFiltering[0];

Initial state to permit announcements.

IF filterMsg#NIL THEN VoiceUtils.Report[filterMsg, $Finch];

};

EDLNames: LIST OF ROPE ← LIST["Arnon.pa", "Beach.pa", "Beretta.pa", "Bier.pa", "Crow.pa", "Diebert.pa", "Glassner.pa", "Pier.pa", "Plass.pa", "PolleZ.pa", "Shoemake.pa", "Stone.pa", "Subhana.pa", "Wyatt.pa"];

AnnounceCmd: Commander.CommandProc = TRUSTED {

list: LIST OF ROPE;

length: INT;

[list, length] ← CommandTool.ParseToList[cmd: cmd];

IF list=NIL THEN list ← EDLNames;

Announce[list];

};

pd.requests ← MBQueue.Create[];

Commander.Register["FReset", FilterResetCmd, "Don't filter calls. This is a test."];

Commander.Register["F0", FilterZeroCmd, "Notifies will time out. This is a test."];

Commander.Register["F1", FilterOneCmd, "Reject all calls. This is a test."];

Commander.Register["F2", FilterTwoCmd, "Accept (ringing) all calls. This is a test."];

Commander.Register["F3", FilterThreeCmd, "Answer all calls (hot line). This is a test."];

Commander.Register["Background", BackgroundCmd,

"FinchTool will supercede background calls."];

Commander.Register["NoBackground", NoBackgroundCmd,

"FinchTool will not supercede background calls."];

InitFiltering[]; -- to permit announcements

Disabled October 3, 1989 4:51:16 pm PDT DCS; for further study.

Commander.Register["Announce", AnnounceCmd,

"Create a com-line like call to a set of Etherphone users."];

Obsolete stuff

Commander.Register["VuFinch", ViewCmd, "Program Management variables Finch"];

BeNice: PROC[r: REF, d: INT] = {

IF NOT pd.doNice THEN RETURN;

Nice.BeNice[r, d, $Finch, NIL];

};

ViewCmd: Commander.CommandProc = TRUSTED {

Nice.View[pd, "Finch PD"];

};

Swinehart, May 22, 1985 1:08:51 pm PDT

Changes to GetParty.

changes to: JayConnection

Polle Zellweger (PTZ) July 13, 1985 5:20:26 pm PDT

adding Text-to-Speech server

changes to: DIRECTORY, ProseSpec, ProseSpecs, stopIntervalSpec (was stopSpec), stopProseSpec, Progress, Supervise, DisconnectCall, PlaceCall, StopSpeech, TextToSpeech, InitFinchSmarts, GetConv, ReportProses, EnqueueProses, Complain, Connect, ProseConnection

Swinehart, August 6, 1985 5:43:08 pm PDT

Merge PTZ prose changes

changes to: DIRECTORY, NB, PD, stopIntervalSpec, stopProseSpec, Report, Progress, Supervise, DisconnectCall, PlaceCall, StopTune, NoiseSpec, PlaybackTune, TextToSpeech, InitFinchSmarts, GetConv, ReportProses, CompareIntID, EnqueueProses, Complain, Connect, JayConnection, ProseConnection, RepRet, FinchSmarts

Polle Zellweger (PTZ) August 19, 1985 4:16:40 pm PDT

Meter text in TextToSpeech so as to avoid sending large ropes all at once. Allows speech to begin sooner and flush faster. Also flushing changes.

changes to: FinchInfo, PD, Supervise, TextToSpeech, StopSpeech, ReportProses (comments only)

Polle Zellweger (PTZ) September 3, 1985 6:28:29 pm PDT

Allow registration of defaultTranslateProc.

changes to: Supervise, defaultTranslateProc, RegisterTranslateProc, TextToSpeech, FinchSmarts

Swinehart, September 16, 1985 10:00:59 am PDT

If Finch has never been initialized, info is NIL -- don't let that bother you.

changes to: GetRname, PlayNoise, FinchOn

Polle Zellweger (PTZ) October 22, 1985 5:10:44 pm PDT

changes to: Progress (add prose debugging reports), TextToSpeech (report connection failure), ReportProses (fix debugging reports), JayConnection (report connection failure), ProseConnection (report connection failure)

Polle Zellweger (PTZ) October 24, 1985 4:53:21 pm PDT

Move bluejayConnection and proseConnection from FinchInfo to ConvDesc.

changes to: Supervise, DisconnectCall, InitFinchSmarts, Connect, JayConnection, ProseConnection

Swinehart, October 28, 1985 12:31:20 pm PST

Merge Above changes with other other minor changes (RefQ and the like)

changes to: DIRECTORY, FinchSmartsImpl, Progress, Supervise, DisconnectCall, TextToSpeech, InitFinchSmarts, UninitFinchSmarts, IsConv, GetConv, IsConv (local of GetConvDesc), GetConvDesc, ReportProses, FinchOn, Connect, JayConnection, ProseConnection, PlaybackTune, ClearConvs (local of UninitFinchSmarts)

Swinehart, December 13, 1985 2:52:25 pm PST

Massive change to new Thrush, leaving out proses and intervals for the moment.

changes to: ConversationHandle, FinchInfo, Progress, Supervise, DisconnectCall, AnswerCall, PlaceCall, Apprise, Complain, Connect, Problem, FinchSmarts, Progress, QdProgress

Swinehart, December 17, 1985 10:05:46 am PST

Major revision for new Thrush. Removed all Prose and Bluejay stuff temporarily

changes to: QdProgress, NoteNewState, PutFTime, Connect, Problem, Progress, Other, Supervise

Swinehart, May 19, 1986 12:22:17 pm PDT

Cedar 6.1

changes to: DIRECTORY, SHHH

Swinehart, June 1, 1986 7:48:10 pm PDT

Add ReportAction, eliminate the MBQueueing of ThParty-provoked actions. Others remain, but should go.

changes to: Progress, Substitution, ReportAction

Doug Terry, August 28, 1986 4:59:33 pm PDT

Changed report registration; removed key distribution; removed routines for recording/playing, tunes and related operations.

changes to: FinchIsRunning, RegisterForReports, UnRegisterForReports, ReportAction, DisconnectCall, PlaceCall, PlaybackTune, NoteNewState, Request, Connect, InitFinchSmarts, UninitFinchSmarts, ReportSystemState, ReportConversationState, ReportRequestState, DIRECTORY, FinchSmartsImpl, GetConv

Doug Terry, August 29, 1986 12:14:14 pm PDT

New interface procedures for FinchSmarts clients to get at voice services: VoiceConnect and LookupServiceInterface.

changes to: ReleaseVisitor, VoiceConnect, WaitForActive, LookupServiceInterface, Problem

Swinehart, June 8, 1987 12:03:11 pm PDT

Remove GList by copying code.

Swinehart, July 14, 1987 4:19:54 pm PDT

Numerous changes to error and connection management. ThPartyClientImpl split out.

Swinehart, July 19, 1987 5:16:39 pm PDT

VoiceConnect => ServiceConnect, more rigid success requirements.

changes to: ServiceConnect, GetActiveConversation, ClearInfo, ObtainServiceInterface

Polle Zellweger (PTZ) July 27, 1987 5:56:47 pm PDT

a bit less rigid success requirements (find $reserved party if offhook when play/record)

changes to: GetActiveConversation

Polle Zellweger (PTZ) July 27, 1987 11:17:01 pm PDT

Allow for better party reports in FinchTool (>2 parties in conversation)

changes to: NoteNewState, us, PartyID

Swinehart, August 30, 1987 9:23:09 pm PDT

Continuing development of connect/disconnect behavior., PollWaiter

Polle Zellweger (PTZ) September 15, 1987 11:36:30 am PDT

Improved error messages for visiting functions; fix bug in NoteNewState that wasn't updating cDesc.ultimateState properly (inhibited coalescing of outside calls in FinchToolImpl).

changes to: IdentifyVisitor, ReleaseVisitor, ReleaseVisitorSelf, NoteNewState

Polle Zellweger (PTZ) September 15, 1987 4:28:01 pm PDT

changes to: IdentifyVisitor, ReleaseVisitor, ReleaseVisitorSelf

Polle Zellweger (PTZ) March 26, 1989 6:48:08 pm PST

Add crude announcement capability.

added: EDLNames, anyone, announcement, mediumPriority, Announce, AnnounceInt, GetCurrentConv

Polle Zellweger (PTZ) March 29, 1989 11:18:43 pm PST

Creature comforts, but without changing interfaces.

changes to: InitFiltering, AnnounceCmd, initialization

Polle Zellweger (PTZ) May 21, 1990 2:23:07 pm PDT

Add UNWINDs to some ENTRY procs that were missing them.

changes to: PlaceCall, PlaceCallInt, Announce, UninitFinchSmarts

Polle Zellweger (PTZ) June 26, 1990 2:27:48 pm PDT

Use Sun RPC for ThSmarts communication.

changes to: InitFinchSmarts

Polle Zellweger (PTZ) August 9, 1990 1:13:08 pm PDT

Be a bit more flexible about state mismatch

changes to: Request

Polle Zellweger (PTZ) August 10, 1990 7:07:40 pm PDT

Set up for LarkFeep via Sun RPC

changes to: DIRECTORY, FinchSmartsImpl, Feep, Request, InitFinchSmarts

Swinehart, September 8, 1990 6:53:41 pm PDT

Redistribute some functions between FinchSmartsImpl and the new FinchRegisterImpl; adapt to new error management code.