[Indigo]<Voice>Thrush>LarkSmartsImpl.mesa!133

LarkSmartsImpl.mesa

Last modified by D. Swinehart, February 11, 1987 7:50:58 pm PST

Last Edited by: Pier, May 3, 1984 3:00:22 pm PDT

Polle Zellweger (PTZ) August 23, 1985 2:21:19 pm PDT

DIRECTORY

Atom USING [ DottedPairNode ],

BasicTime USING [ GMT, Now, Pack, Period, ToNSTime, Unpack, Unpacked, Update ],

IO,

Lark,

LarkFeepRpcControl,

LarkSmartsMonitorImpl,

MBQueue USING [ QueueClientAction ],

NamesGV USING [ AttributeSeq, AttributeSeqRec, GVSetAttribute, GVSetAttributeSeq ],

RefID USING [ ID, Reseal, Unseal ],

Rope USING [ Concat, Equal, Fetch, FromChar, Length ],

SafeStorage USING [ NarrowRefFault ],

ThParty USING [ Alert, CreateConversation, GetPartyFromNumber, GetPartyFromFeepNum, GetPartyInfo, LookupServiceInterface, PartyInfo ],

Thrush USING [

ConversationID, ConvEvent, InterfaceSpec, PartyID, NB, none, nullConvID, nullID, ROPE, StateInConv ],

ThSmartsPrivate USING [

ChangeState, ConvDesc, DBInfo, EnterLarkState, ForgetConv, InputEventSpec, GetConv, LarkInfo, NoteNewState, OpenConversations, ParseState, SmartsInfo ],

VoiceUtils USING [ MakeAtom, Problem ]

;

LarkSmartsImpl: CEDAR MONITOR LOCKS root

IMPORTS

BasicTime,

IO,

MBQueue,

LarkFeepRpcControl,

root: LarkSmartsMonitorImpl,

NamesGV,

RefID,

Rope,

SafeStorage,

ThParty,

ThSmartsPrivate,

VoiceUtils

EXPORTS ThSmartsPrivate

SHARES LarkSmartsMonitorImpl = {

OPEN IO;

Copies

CommandEvents: TYPE = Lark.CommandEvents;

ConversationID: TYPE = Thrush.ConversationID;

nullConvID: ConversationID=Thrush.nullConvID;

ConvDesc: TYPE = ThSmartsPrivate.ConvDesc;

disabled: Lark.Event = Lark.disabled;

enabled: Lark.Event = Lark.enabled;

endNum: Lark.Event = Lark.endNum;

Reseal: PROC[r: REF] RETURNS[RefID.ID] = INLINE {RETURN[RefID.Reseal[r]]; };

LarkInfo: TYPE = ThSmartsPrivate.LarkInfo;

NB: TYPE = Thrush.NB;

nullID: RefID.ID = Thrush.nullID;

OpenConversations: TYPE = ThSmartsPrivate.OpenConversations;

PartyID: TYPE = Thrush.PartyID;

ROPE: TYPE = Thrush.ROPE;

SHHH: TYPE = Lark.SHHH; -- Encrypts conv. if first arg to RPC PROC

SmartsInfo: TYPE = ThSmartsPrivate.SmartsInfo;

StateInConv: TYPE = Thrush.StateInConv;

StatusEvents: TYPE = Lark.StatusEvents;

Parsing

ParseEvent handles events from the EtherPhone, by queuing them to synchronize with other activities.

LarkParseEvent: PUBLIC ENTRY PROC[r: REF] = { -- r is the InputEventSpec

ENABLE UNWIND=>NULL;

eventSpec: ThSmartsPrivate.InputEventSpec = NARROW[r];

smartsInfo: SmartsInfo = eventSpec.smartsInfo;

sEvent: Lark.StatusEvent ← eventSpec.sEvent;

IF smartsInfo=NIL OR smartsInfo.failed THEN RETURN; -- Events directed at dead smarts

SELECT sEvent.device FROM

nothing => RETURN;

speakerSwitch, touchPad, hookSwitch => NULL;

ENDCASE => ERROR;

DoParse[smartsInfo, sEvent.event]; -- Interpret this event in light of past ones.

IF smartsInfo.haveArguments THEN { -- now are ready to execute an action routine

val: INT𡤀

IF smartsInfo.Command=NIL THEN smartsInfo.Command ← CmdCall; -- was a phone number

SELECT smartsInfo.parseState FROM

inNum => val ← IO.GetInt[IO.RIS[smartsInfo.arguments]!

IO.Error => SELECT ec FROM Failure, SyntaxError, Overflow => CONTINUE; ENDCASE];

ENDCASE;

smartsInfo.Command[smartsInfo, val]; -- Execute the action routine

[]←SetParserIdle[smartsInfo, TRUE, TRUE];

};

DoParse: INTERNAL PROC[info: SmartsInfo, event: Lark.Event] = {

In the name of unexcess generality, this procedure parses all of the commands: call placement, message handling, call management, and so on. Could change to call sequential registered procedures and like that, if more flexibility is needed. Hairy touchpad user interfaces aren't a major goal of this work.

IF info.haveOne=FALSE AND event#disabled AND GetSIC[info] = $reserved THEN

IF ThSmartsPrivate.ChangeState[GetConvDesc[info], $parsing] # $success THEN

{ []←SetParserIdle[info, TRUE, FALSE]; RETURN; }; -- just get out!

See Log notes, November 29, 1985 11:18:59 am PST

info.haveOne ← TRUE;

SELECT event FROM

On/Offhook

disabled => { info.haveArguments ← TRUE; info.Command ← CmdOnhook; RETURN;};

enabled => { info.haveArguments ← TRUE; info.Command ← CmdOffhook; RETURN;};

Termination of arguments, DEL

endNum => { info.haveArguments ← TRUE; RETURN; }; -- '#

IO.DEL, IO.ESC => { []←SetParserIdle[info, TRUE, TRUE]; RETURN; };

Command or recipient initiation

'* => {

IF info.cmdOrRecip THEN info.offset�

info.cmdOrRecip ← TRUE; info.parseState ← idle;

RETURN;

};

Valid argument event

ENDCASE => NULL; -- continues below

IF info.cmdOrRecip THEN { -- begins command or feepName recipient specification

info.cmdOrRecip ← FALSE;

event𡤎vent+info.offset;

info.offset𡤀

IF event = '0 THEN { -- feepName recipient specification

[]←SetParserIdle[info, FALSE, FALSE]; info.parseState ← getFeep; RETURN; };

[]←SetParserIdle[info, TRUE, FALSE];

SELECT event FROM

Here are the commands

'*, -- esc

endNum -- del -- => []←SetParserIdle[info, TRUE, TRUE];

IN ['1..'9] => { []←SetParserIdle[info, FALSE, FALSE]; info.parseState ← getFeep; GOTO Continue; };

Continue to collect event as first character of feep name!

'0+10, 'T, 't => { info.Command ← CmdBackDoor; info.haveArguments ← TRUE; };

**0

'1+10 => { info.Command ← CmdRingOff; info.haveArguments ← TRUE; };

'2+10 => { info.Command ← CmdRingOn; info.haveArguments ← TRUE; };

'3+10 => { info.Command ← CmdRingOffTimed; info.parseState ← getNum; };

'4+10 => { info.Command ← CmdRingOnce; info.haveArguments ← TRUE; };

'5+10 => { info.Command𡤌mdRingOnceTimed; info.parseState ← getNum; };

'7+10 => { info.Command← CmdAudioSource; info.haveArguments ← TRUE; info.arguments ← "telset"; };

'8+10 => { info.Command← CmdAudioSource; info.haveArguments ← TRUE; info.arguments ← "lineA"; };

'9+10 => { info.Command← CmdAudioSource; info.haveArguments ← TRUE; info.arguments ← "lineB"; };

ENDCASE => -- unassigned same as DEL -- NULL;

RETURN;

EXITS Continue => NULL;

};

A letter, digit, or other non-activation character.

info.arguments ← Rope.Concat[info.arguments, Rope.FromChar[event]];

info.parseState ← SELECT event FROM

IN ['0..'9] => SELECT info.parseState FROM

idle => inSeq,

getFeep => inFeep,

getNum => inNum,

getStr => inStr,

ENDCASE => info.parseState,

ENDCASE => SELECT info.parseState FROM

idle, getStr => inStr,

getFeep, getNum, inFeep, inNum => inTossStr,

inSeq => SetParserIdle[info, TRUE],

ENDCASE => info.parseState;

IF info.parseState = inSeq THEN {

Sequence of digits whose length is determined by the values of the first character or two

e1: Lark.Event = info.arguments.Fetch[0];

SELECT info.arguments.Length[] FROM

1 => SELECT event FROM

'0 => info.haveArguments←TRUE; -- PARC Operator

'4, '5, '6, '7, '8, '9 => NULL; -- seq-type number continues

ENDCASE => info.parseState ← inNum;

Require explicit termination of calls beginning with unrecognized prefixes

2 => IF info.arguments.Equal["90"] THEN info.parseState ← inNum;

Require explicit termination of international calls, calling card calls, calls to Telco Operator

3 => IF info.arguments.Equal["911"] THEN info.haveArguments←TRUE;

4 => SELECT e1 FROM

'9 => IF info.arguments.Equal["9911"] THEN info.haveArguments ← TRUE;

'4, '5, '6 => info.haveArguments ← TRUE; -- local extensions

ENDCASE;

5 => SELECT e1 FROM

'7 => info.haveArguments ← TRUE; -- Xerox Sunnyvale extensions

ENDCASE;

8 => IF info.arguments.Fetch[2] > '1 THEN info.haveArguments ← TRUE;

Local or Intelnet

11 => info.haveArguments ← TRUE; -- DDD call, via ATT or Intelnet

ENDCASE; -- keep on going

};

SetParserIdle: INTERNAL PROC[info: SmartsInfo, clearCmd: BOOL, reallyIdle: BOOL←TRUE]

RETURNS [ ThSmartsPrivate.ParseState ] = {

info.haveArguments ← info.haveOne ← FALSE;

info.parseState ← idle; info.arguments ← NIL;

info.offset ← 0; info.cmdOrRecip ← FALSE;

IF clearCmd THEN info.Command ← NIL;

IF reallyIdle THEN SELECT GetSIC[info] FROM

$parsing => IF ThSmartsPrivate.ChangeState[GetConvDesc[info], $reserved] # $success

THEN info.Command ← NIL; -- Massive failure, control damage.

ENDCASE;

RETURN[idle];

};

User-invoked actions

CmdCall: INTERNAL PROC[info: SmartsInfo, val: INT] = {

User has specified feep name or number;

cDesc: ConvDesc;

{

OPEN now: cDesc.situation.self;

nb: NB;

partyID: PartyID;

otherPartyID: PartyID;

IF info.arguments=NIL OR info.parseState=$inTossStr THEN RETURN;

SELECT GetSIC[info] FROM

$reserved, $parsing => NULL;

$active => RETURN; -- ignore further DTMF signalling activity after call is active

ENDCASE => {

VoiceUtils.Problem["LarkSmarts placing call from wrong state"]; RETURN; };

cDesc ← GetConvDesc[info];

IF cDesc=NIL THEN RETURN; -- Error already reported by GetConvDesc.

partyID ← now.partyID;

[nb, otherPartyID] ← GetPartiesForCall[info, partyID, info.parseState, info.arguments];

SELECT nb FROM

$success => NULL;

$noSuchParty2 =>

{ [] ← ThSmartsPrivate.ChangeState[cDesc, $failed, $notFound]; RETURN; };

$voiceTerminalBusy => -- front/back door thing

{ [] ← ThSmartsPrivate.ChangeState[cDesc, $failed, $busy, "Only available trunk line is in use"]; RETURN; }; -- Unlikely to happen.

ENDCASE => RETURN; -- Problems already reported, nothing more can be done.

IF ThSmartsPrivate.ChangeState[cDesc, $initiating] = $success THEN {

comment: ROPE ← NIL;

SELECT (nb←ThParty.Alert[credentials: now, calledPartyID: otherPartyID]) FROM

$success => RETURN;

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

$noSuchParty2, $voiceTerminalBusy, $alreadyInConv =>

comment ← "Called party cannot be contacted";

$noSuchParty, $noSuchSmarts, $noSuchConv, $notInConv, $convIdle, $stateMismatch, $interfaceError => {

VoiceUtils.Problem["Serious Party error detected by LarkSmarts"];

ThSmartsPrivate.ForgetConv[cDesc]; RETURN;

};

Consider removing some of these if other reports always preceed them.

Might have to do ForgetConversation and/or ThSmarts.Fail. See what Advance does with these things, first.

ENDCASE => ERROR; -- Unexpected

[] ← ThSmartsPrivate.ChangeState[cDesc, $failed, $busy, comment];

};

}; };

CmdBackDoor: INTERNAL PROC[info: SmartsInfo, val: INT] = {

To work properly, this would have to be a communication to the "Feep" interface of the other party. Check out how LarkSmarts.Feep works. Fix Feep in the forwarded case.

cDesc: ConvDesc ← GetConvDesc[info];

IF cDesc#NIL AND cDesc.situation.self.state=$active THEN {

pInfo: ThParty.PartyInfo;

interfaceSpec: Thrush.InterfaceSpec;

interface: LarkFeepRpcControl.InterfaceRecord←NIL;

nb: NB;

[nb, pInfo] ←

ThParty.GetPartyInfo[credentials: cDesc.situation.self, nameReq: $none, allParties: TRUE];

IF nb # $success OR pInfo[0].partyID=0 THEN {

VoiceUtils.Problem["No conversation info, or incomplete"]; RETURN; }; -- This is really bad!

IF pInfo.conversationInfo.numActive#2 OR ~pInfo.conversationInfo.bilateralConv

THEN RETURN;

[nb, interfaceSpec] ←

ThParty.LookupServiceInterface[

credentials: cDesc.situation.self, serviceParty: pInfo[1].partyID, type: "LarkFeep"];

IF nb#$success THEN RETURN;

interface ← NARROW[RefID.Unseal[interfaceSpec.interfaceID]!

SafeStorage.NarrowRefFault => CONTINUE]; -- Insist on a local implementation.

IF interface=NIL THEN RETURN; -- flashing has no meaning in this conversation.

IF interface.Flash[shhh: Thrush.none, serviceID: interfaceSpec.serviceID,

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

actionID: 0, extraTime: 177777B] # $success THEN

VoiceUtils.Problem["Switchhook flash failed"];

RETURN; };

info.arguments ← ""; -- non-nil, but no value either.

info.parseState ← $inSeq;

CmdCall[info, val];

};

CmdOnhook: INTERNAL PROC[info: SmartsInfo, val: INT] = {

cDesc: ConvDesc;

SELECT GetSIC[info] FROM

$idle, $notified, $ringing, $neverWas => RETURN; -- could still be offhook from last call.

ENDCASE => NULL;

cDesc ← GetConvDesc[info];

[] ← ThSmartsPrivate.ChangeState[cDesc, $idle, $terminating];

};

CmdOffhook: INTERNAL PROC[info: SmartsInfo, val: INT] = {

desiredState: StateInConv ← $active;

nb: NB;

cDesc: ConvDesc;

SELECT GetSIC[info] FROM

$idle => {

convEvent: Thrush.ConvEvent;

cDesc ← ThSmartsPrivate.GetConv[info, nullConvID, TRUE];

[nb, convEvent] ← ThParty.CreateConversation[

credentials: cDesc.situation.self,

state: $reserved

];

SELECT nb FROM

$success => NULL;

$noSuchSmarts, $noSuchParty => {

VoiceUtils.Problem["Serious party error noted by LarkSmarts"];

ThSmartsPrivate.ForgetConv[cDesc]; -- see above about possible Fail, Forget actions.

RETURN;

};

ENDCASE => ERROR; -- Unexpected

ThSmartsPrivate.NoteNewState[cDesc, convEvent];

};

$ringing => {

cDesc ← GetConvDesc[info];

IF cDesc=NIL THEN RETURN; -- Error has been reported

[] ← ThSmartsPrivate.ChangeState[cDesc, $active];

};

ENDCASE

};

Data base changes -- ringing specifications and so on.

CmdRingOff: INTERNAL PROC[info: SmartsInfo, val: INT] = {

DoRingSpec[info, "O", $timedringmode]};

CmdRingOn: INTERNAL PROC[info: SmartsInfo, val: INT] = {

DoRingSpec[info,"R", $ringmode]};

CmdRingOffTimed: INTERNAL PROC[info: SmartsInfo, val: INT] = {

DoRingSpec[info,"O",$timedringmode, val]};

CmdRingOnce: INTERNAL PROC[info: SmartsInfo, val: INT] = {

DoRingSpec[info,"S", $ringmode]; };

CmdRingOnceTimed: INTERNAL PROC[info: SmartsInfo, val: INT] ={

DoRingSpec[info,"S",$timedringmode, val]};

RingSpec: TYPE = REF RingObj;

RingObj: TYPE = RECORD [

info: SmartsInfo,

ringMode: ROPE,

ringModeAttribute: ATOM,

timeInMinutes: INT

];

DoRingSpec: INTERNAL PROC[info: SmartsInfo, ringMode: ROPE,

ringModeAttribute: ATOM, timeInMinutes: INT←1441-- default one day and one second--] = {

Queue it to release user interface

IF timeInMinutes=0 THEN timeInMinutes ← 30; -- default one day and one second

info.requests.QueueClientAction[QdRing,

NEW[RingObj ← [info, ringMode, ringModeAttribute, timeInMinutes]]];

};

QdRing: ENTRY PROC[r: REF] = {

ringSpec: RingSpec ← NARROW[r];

partyID: PartyID;

rName: ROPE;

info: SmartsInfo = ringSpec.info;

cDesc: ConvDesc = ThSmartsPrivate.GetConv[info, info.currentConvID, FALSE];

now: BasicTime.GMT;

unp: BasicTime.Unpacked;

interval: INT ← ringSpec.timeInMinutes*60;

IF cDesc=NIL THEN RETURN; -- should make error signal, but that's too hard.

rName ← ThSmartsPrivate.DBInfo[partyID ← cDesc.situation.self.partyID].dbRname;

IF rName=NIL THEN RETURN; -- should make error signals

Set timed or standard ring mode attribute

SELECT ringSpec.ringModeAttribute FROM

$ringmode => NamesGV.GVSetAttribute[rName, $ringmode, ringSpec.ringMode];

$timedringmode => {

as: NamesGV.AttributeSeq ← NEW[NamesGV.AttributeSeqRec[2]];

as.length ← 2;

If timed, set time to minimum of now+(ringSpec.time)*60 and midnight in minutes

unp ← BasicTime.Unpack[now ← BasicTime.Now[]];

unp.hour ← 23;

unp.minute ← 59;

unp.second ← 59; -- midnight

interval ← MIN[interval, BasicTime.Period[from: now, to: BasicTime.Pack[unp]]+1];

as[0] ← [$timed,

IO.PutFR["%g", card[BasicTime.ToNSTime[BasicTime.Update[now, interval]]]]];

as[1] ← [$unspec, ringSpec.ringMode];

NamesGV.GVSetAttributeSeq[rName, $ringmode, as];

};

ENDCASE => ERROR;

};

CmdAudioSource: INTERNAL PROC[info: SmartsInfo, val: INT] = {

IF info.arguments.Length[]=0 THEN info.arguments←"telset";

IF info.larkInfo=NIL THEN RETURN;

ThSmartsPrivate.EnterLarkState[info.larkInfo, info.larkInfo.larkState,

LIST[NEW[Atom.DottedPairNode←[$audioSource, VoiceUtils.MakeAtom[info.arguments]]]]];

};

Connection Management Utilities

GetConvDesc: PUBLIC INTERNAL PROC[info: SmartsInfo] RETURNS [ cDesc: ConvDesc ] = {

RETURN[IF info.currentConvID = nullConvID THEN NIL

ELSE ThSmartsPrivate.GetConv[ info, info.currentConvID, FALSE ]];

};

GetSIC: PUBLIC INTERNAL PROC[info: SmartsInfo]

RETURNS [ state: StateInConv ] = {

cDesc: ConvDesc = GetConvDesc[info];

state ← IF cDesc=NIL THEN $idle ELSE cDesc.situation.self.state;

};

GetPartiesForCall: PROC[

info: SmartsInfo, partyID: PartyID, parseState: ThSmartsPrivate.ParseState, args: ROPE]

RETURNS[nb: NB← $noSuchParty, calledPartyID: PartyID ← nullID ] = {

IF partyID = nullID THEN RETURN;

SELECT parseState FROM

inSeq, inNum => [nb, calledPartyID] ← ThParty.GetPartyFromNumber[

partyID: partyID, phoneNumber: args];

inFeep =>

[nb, calledPartyID] ← ThParty.GetPartyFromFeepNum[partyID: partyID, feepNum: args];

inStr => complain — see below;

ENDCASE => VoiceUtils.Problem["Don't know how to look for called party", $Smarts, info];

SELECT nb FROM

$success, $voiceTerminalBusy, $noSuchParty2 => RETURN;

ENDCASE;

VoiceUtils.Problem["Serious Party problem detected at LarkSmarts"];

};

GetPartiesForCall.nb~$noSuchParty

GetPartiesForCall.GetPartyFromNumber/FeepNum.nb~~$noSuchParty

GetPartiesForCall.GetRelatedParty.nb~~$voiceTerminalBusy

GetPartiesForCall.GetPartyFromNumber/FeepNum.nb~~$noSuchParty2

GetPartiesForCall.GetRelatedParty.nb~~$convStillActive

GetPartiesForCall.GetIdleParty/GetRnameFromParty.nb~~$noNameAvailable

GetPartyFromFeepNum.GetActiveParty.nb~~$noIdentSupplied

Swinehart, May 22, 1985 12:14:29 pm PDT

hotLine => autoAnswer

changes to: DoParse, CmdHotline, }

Polle Zellweger (PTZ) August 23, 1985 2:21:19 pm PDT

Consistency checking on devices.

changes to: LarkParseEvent, DIRECTORY

Swinehart, October 28, 1985 9:51:23 am PST

Handle => ID, Log => VoiceUtils, pull ProblemHandle, ...

changes to: DIRECTORY, LarkSmartsImpl, ConversationID, Reseal, nullID, PartyID, LarkParseEvent, CmdCall, CmdOffhook, CmdRingDoProc, GetCDesc, GetPartiesForCall, ProblemID

Swinehart, November 29, 1985 11:19:02 am PST

When event is disabled (hanging up), don't transition into $parsing because there will soon be a transition into $idle

changes to: DoParse

Swinehart, December 29, 1986 3:37:31 pm PST

Remove obsolete $voiceTerminalBusy nb test

changes to: CmdCall, GetPartiesForCall, CmdOffhook

Swinehart, January 1, 1987 9:49:59 pm PST

Still working on FD/BD conflict code.

changes to: CmdCall, CmdAudioSource

Swinehart, January 28, 1987 8:13:00 am PST

A pass for error management, esp. nb-processing

changes to: StatusEvents, LarkParseEvent, DoParse, SetParserIdle, CmdCall, CmdBackDoor, CmdOnhook, CmdOffhook, GetPartiesForCall