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

LarkSmartsImpl.mesa

Last modified by D. Swinehart, May 1, 1986 1:54:17 pm PDT

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 ],

Convert USING [ RopeFromCard ],

IO,

Lark,

LarkSmartsMonitorImpl,

MBQueue USING [ QueueClientAction ],

NamesGV USING [ GVSetAttribute ],

RefID USING [ ID, Reseal ],

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

ThParty USING [ Alert, CreateConversation, GetPartyFromNumber, GetPartyFromFeepNum ],

Thrush USING [

ConversationID, ConvEvent, IntervalSpec, PartyID, NB, nullConvID, nullID, ROPE, StateInConv ],

ThSmartsPrivate USING [

AssessDamage, ChangeState, ConvDesc, DBInfo, Deregister, EnableSmarts, EnterLarkState, ForgetConv, GetConv, InterpretHookState, LarkFailed, LarkInfo, NoteNewState, OpenConversations, ParseState, SmartsInfo ],

TU USING [ RefAddr ],

VoiceUtils USING [ MakeAtom, Problem, ProblemFR ]

;

LarkSmartsImpl: CEDAR MONITOR LOCKS root

IMPORTS

BasicTime,

Convert,

IO,

MBQueue,

root: LarkSmartsMonitorImpl,

NamesGV,

RefID,

Rope,

ThParty,

ThSmartsPrivate,

TU,

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]]; };

IntervalSpec: TYPE = Thrush.IntervalSpec;

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.

EventSpec: TYPE = REF EventSpecBody;

EventSpecBody: TYPE = RECORD [

smartsInfo: SmartsInfo,

sEvent: Lark.StatusEvent

];

LarkParseEvent: PUBLIC PROC[

smartsInfo: SmartsInfo, sEvent: Lark.StatusEvent] = {

smartsInfo.requests.QueueClientAction[

QdLarkParseEvent, NEW[EventSpecBody ← [smartsInfo, sEvent]]];

};

QdLarkParseEvent: ENTRY PROC[r: REF] = { -- r is the EventSpec

eventSpec: EventSpec = NARROW[r];

smartsInfo: SmartsInfo = eventSpec.smartsInfo; {

ENABLE {

UNWIND=>NULL;

ThSmartsPrivate.LarkFailed => { VoiceUtils.ProblemFR["%g: Lark Failed", $Smarts, smartsInfo, TU.RefAddr[smartsInfo]]; GOTO Failed; };

};

sEvent: Lark.StatusEvent ← eventSpec.sEvent;

IF ~LarkEnabled[smartsInfo] THEN RETURN; -- don't interfere with reverted call!

sEvent ← ThSmartsPrivate.InterpretHookState[smartsInfo.larkInfo, sEvent, smartsInfo];

Deal with ring-detect bounce, speaker switch clicks, and the like.

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];

};

The rest of this has to be done in the places where the situations arise.

Be sure state of conv. and tones agree with state of parsing.

<<This feels like in the wrong place. Oughta be done by a command proc of some sort?

Or get rid of the command procs?>>

cDesc ← GetConvDesc[smartsInfo];

IF cDesc#NIL THEN {

OPEN now: cDesc.situation.self;

SELECT now.state FROM

# desired.state => RETURN; -- some request already in the works.

reserved => IF smartsInfo.haveOne THEN desired.state←parsing ELSE RETURN;

parsing => IF smartsInfo.haveOne THEN RETURN ELSE {

desired.state←reserved; cDesc.desiredSituation.reason ← NIL; };

ENDCASE=>RETURN;

ThSmartsPrivate.Apprise[smartsInfo];

};

EXITS

Failed => ThSmartsPrivate.Deregister[smartsInfo.smartsID];

}; };

LarkEnabled: INTERNAL PROC[info: SmartsInfo] RETURNS [enabled: BOOL] = INLINE {

RETURN[SELECT info.larkInfo.larkState FROM

none => ThSmartsPrivate.EnableSmarts[info],

failed, recovering => FALSE,

ENDCASE => 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.

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

[--nb--] ← ThSmartsPrivate.ChangeState[GetConvDesc[info], $parsing];

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, '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;

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 => [] ← ThSmartsPrivate.ChangeState[GetConvDesc[info], $reserved]; -- error?

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;

partyID: PartyID;

otherPartyID: PartyID;

nb: NB;

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

SELECT GetSIC[info] FROM

$reserved, $parsing => NULL; ENDCASE => RETURN;

cDesc ← GetConvDesc[info];

IF cDesc=NIL THEN RETURN; -- report error, enter error state?

partyID ← now.partyID;

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

SELECT nb FROM

$success => NULL;

$noSuchParty, -- Serious business; analyze this!

$noSuchParty2 =>

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

$narcissism =>

{ [--nb--] ← ThSmartsPrivate.ChangeState[cDesc, $failed, $notFound, "Attempt to call self rejected on philisophical grounds"]; RETURN; };

$voiceTerminalBusy => -- front/back door thing

{ [--nb--] ← ThSmartsPrivate.ChangeState[cDesc, $failed, $busy, "Called Etherphone's phone line is in use"]; RETURN; };

ENDCASE => GOTO Failed;

IF (nb ← ThSmartsPrivate.ChangeState[cDesc, $initiating]) = $success THEN

nb←ThParty.Alert[credentials: now, calledPartyID: otherPartyID];

IF nb # $success THEN GOTO Failed; -- enter error state?

EXITS

Failed => [--nb--] ← ThSmartsPrivate.ChangeState[cDesc, $failed, $notFound];

System failure or unexpected case; analyze!!

See LarkSmartsSupImpl.AssessDamage for the kinds of errors that occur here. Nobody's catching them, so they have to be dealt with here.

}; };

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

IF GetSIC[info]=$active AND info.larkInfo.larkState = $trunkTalking THEN { -- Hack

ThSmartsPrivate.EnterLarkState[info.larkInfo, $trunkFlashing]; 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];

[--nb--] ← 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

];

IF nb # $success THEN {

ThSmartsPrivate.AssessDamage[nb, cDesc, convEvent];

ThSmartsPrivate.ForgetConv[cDesc];

No idea what to do!

}

ELSE ThSmartsPrivate.NoteNewState[cDesc, convEvent];

};

$ringing => {

cDesc ← GetConvDesc[info];

IF cDesc=NIL THEN RETURN; -- Is this an error?

[--nb--]←ThSmartsPrivate.ChangeState[cDesc, desiredState]; -- Complain on error?

};

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

NamesGV.GVSetAttribute[rName, ringSpec.ringModeAttribute, ringSpec.ringMode];

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

IF ringSpec.ringModeAttribute # $timedringmode THEN RETURN;

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];

NamesGV.GVSetAttribute[rName, $expiration,

Convert.RopeFromCard[BasicTime.ToNSTime[BasicTime.Update[now, interval]]]];

};

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];

};

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