adgsm.pas

Async Professional 4.04

  GSMWriteToMemoryResponse : array[0..1] of string =
               (#13#10,             // Response StartString expected
                '+CMGW: ');
  GSMDeleteAMessageCommand : array[0..0] of string =
               ('+CMGD=');            // Delete Message from Memory
  GSMDeleteAMessageResponse : array[0..0] of string =
               (#13#10'OK');               // No Response Expected, just OK

{ TApdCustomGSMPhone }

{ opens the port, issues configuration commands }
{Generates the OnMessageList (+CMGL) event when complete if not QuickConnect}
procedure TApdCustomGSMPhone.Connect;
var
  Res : Integer;
  ET : EventTimer;
{$IFDEF TRIALRUN}
  {$I TRIAL04.INC}
{$ENDIF}
begin
  {$IFDEF TRIALRUN}
  TC;
  {$ENDIF}

  if FGSMState > gsNone then begin
    DoFail(secSMSBusy,-8100);
    Exit;
  end;
  if not FConnected then begin
    { Do connection/configuration stuff }
    CheckPort;
  end;
  if FNotifyOnNewMessage then begin                                      {!!.02}
    NotifyPacket.Enabled := True;                                        {!!.02}
    NotifyPacket.AutoEnable := True;                                     {!!.02}
  end;                                                                   {!!.02}
  FConfigList := True;                                                   {!!.02}
  CmdIndex := 0;
  ResponsePacket.StartString := GSMConfigResponse[CmdIndex];
  ResponsePacket.EndString := #13;  
  ResponsePacket.Enabled := True;
  //DelayTicks(4, True);                                                 {!!.04}
  SetState(gsConfig);
  FComPort.Output := 'AT' + GSMConfigAvail[CmdIndex] + #13;
  NewTimer(ET, 1080); // 60 second timer
  repeat
    Res := SafeYield;
  until (FGSMState = gsNone) or (FGSMState = gsListAll) or (Res = wm_Quit)
        or TimerExpired(ET);
  if TimerExpired(ET) then begin
    DoFail(secSMSTimedOut,-8101);
    Exit;
  end;
end;

constructor TApdCustomGSMPhone.Create(AOwner: TComponent);
begin
  inherited;
  ResponsePacket := TApdDataPacket.Create(Self);
  ResponsePacket.OnStringPacket := ResponseStringPacket;
  ResponsePacket.StartCond := scString;
  ResponsePacket.EndCond := [ecString];
  ResponsePacket.EndString := #13;
  ResponsePacket.Enabled := False;
  ResponsePacket.AutoEnable := False;
  ResponsePacket.IncludeStrings := False;

  ErrorPacket := TApdDataPacket.Create(Self);
  ErrorPacket.OnStringPacket := ErrorStringPacket;
  ErrorPacket.IncludeStrings := False;
  ErrorPacket.StartCond := scString;
  ErrorPacket.StartString := #13#10'ERROR';
  ErrorPacket.EndCond := [ecString];
  ErrorPacket.EndString := #13;
  ErrorPacket.Enabled := False;
  ErrorPacket.AutoEnable := False;
  FConnected := False;
  FNeedNewMessage := 0;                                                  {!!.04}
  FHandle := AllocateHWnd(WndProc);
  FMessageStore := TApdMessageStore.Create(Self);
  FComPort := SearchComPort(Owner);

  NotifyPacket := TApdDataPacket.Create(Self);                           {!!.02}
  NotifyPacket.OnStringPacket := NotifyStringPacket;                     {!!.02}
  NotifyPacket.StartCond := scString;                                    {!!.02}
  NotifyPacket.StartString := '+CMTI:';                                  {!!.02}
  NotifyPacket.EndCond := [ecString];                                    {!!.02}
  NotifyPacket.EndString := #13;                                         {!!.02}
  NotifyPacket.Enabled := False;                                         {!!.02}
  NotifyPacket.AutoEnable := False;                                      {!!.02}
  NotifyPacket.IncludeStrings := False;                                  {!!.02}
end;

destructor TApdCustomGSMPhone.Destroy;
begin
  FConnected := False;
  ResponsePacket.Free;
  ErrorPacket.Free;
  NotifyPacket.Free;                                                     {!!.02}
  FMessageStore.Clear;
  FMessageStore.Free;
  DeallocateHwnd(FHandle);
  inherited;
end;


{ +CMS ERROR: message Service Failure Result Code }
procedure TApdCustomGSMPhone.ErrorStringPacket(Sender: TObject;
  Data: string);
var
  ErrorCode : Integer;
  ErrorMessage : string;
  Temp : string;
begin
  //Display Message Service Failure Result Code
  Temp := Data;
  Temp := Copy(Data, 1, Pos(' ',Data));
  ErrorCode := -8000 - StrToInt(Temp);
  ErrorMessage := Copy(Data, Pos(' ',Data), Length(Data));
  raise Exception.Create('Exception ' + IntToStr(ErrorCode) + ' ' +
                          ErrorMessage);
end;

procedure TApdCustomGSMPhone.ResponseStringPacket(Sender: TObject;
  Data: string);
begin
  // Handle data from packet -State Machine-
  ResponseStr := Data;
  PostMessage(FHandle, ApdGSMResponse, 0,0);
end;

procedure TApdCustomGSMPhone.NotifyStringPacket(Sender: TObject;         {!!.02}
  Data: string);                                                         {!!.02}
var                                                                      {!!.02}
  MessageIndex : Integer;                                                {!!.02}
begin                                                                    {!!.02}
  NotifyStr := Data;                                                     {!!.02}
  if NotifyStr <> '' then begin                                          {!!.02}
    if assigned(FOnNewMessage) then begin                                {!!.02}
      NotifyStr := Copy(NotifyStr,
        Pos('",', NotifyStr) + 2, Length(NotifyStr));                    {!!.02}
      MessageIndex := StrToInt(NotifyStr);                               {!!.02}
      if Assigned(FOnNewMessage) then begin                              {!!.02}
      { if OnNewMessage event then PostMessage to Synchronize/ListAllMessages }
        FNeedNewMessage := MessageIndex;                                 {!!.04}
        PostMessage(FHandle, ApdGSMResponse, 1,0);                       {!!.04}
//        FOnNewMessage(Self, MessageIndex, TheMessage);         {!!.02} {!!.04}
      end;                                                               {!!.04}
    end;                                                                 {!!.02}
  end;                                                                   {!!.02}
end;                                                                     {!!.02}

{ issues +CMGL to list all messages with a Status of ssUnsend}
procedure TApdCustomGSMPhone.ListAllMessages;
var
  Res : Integer;
  ET : EventTimer;
begin   
  if FGSMState > gsNone then begin
    DoFail(secSMSBusy,-8100);
    Exit;
  end;
  if not FConnected then begin
    { Do connection/configuration stuff }
    DoFail(secBadOperation,-8302);
    Exit;
  end;
  CmdIndex := 0;
  SetState(gsListAll);
  FMessageStore.ClearStore;
  FComPort.FlushInBuffer;
  ResponsePacket.StartCond := scAnyData;                                 {!!.02}
  //ResponsePacket.StartString := #13#10;                                {!!.02}
  //ResponsePacket.StartString := '+CMGL: ';                             {!!.02}
  ResponsePacket.EndString := #13#10'OK'#13#10;                          {!!.02}
  ResponsePacket.IncludeStrings := True;                                 {!!.04}
  ResponsePacket.Enabled := True;
  //DelayTicks(4, True);                                                 {!!.04}
  FComPort.Output := 'AT' + GSMListAllMessagesCommands[CmdIndex] + #13;
  NewTimer(ET, 1080); // 60 second timer
  repeat
    Res := SafeYield;
  until (FGSMState = gsNone) or (Res = wm_Quit) or TimerExpired(ET);
  if TimerExpired(ET) then begin
    DoFail(secSMSTimedOut,-8101);
    Exit;
  end;
end;

{ issues +CMSS to send message from storage indexed by Index }
procedure TApdCustomGSMPhone.SendFromMemory(TheIndex: Integer);
var
  Res : Integer;
  ET : EventTimer;
begin
  if FGSMState > gsNone then begin
    DoFail(secSMSBusy,-8100);
    Exit;
  end;
  if not FConnected then begin
    { Do connection/configuration stuff }
    FQuickConnect := False;
    Connect;
  end;
  CmdIndex := 0;
  SetState(gsSendFStore);
  ResponsePacket.StartString := '+CMSS: ';
  ResponsePacket.EndString := #13#10'OK';
  ResponsePacket.Enabled := True;
  //DelayTicks(4, True);                                                 {!!.04}
  FComPort.Output := 'AT' + GSMSendMessFromStorage[CmdIndex] +
                     IntToStr(TheIndex) + #13;
  NewTimer(ET, 1080); // 60 second timer
  repeat
    Res := SafeYield;
  until (FGSMState = gsNone) or (Res = wm_Quit) or TimerExpired(ET);
  if TimerExpired(ET) then begin
    DoFail(secSMSTimedOut,-8101);
    Exit;
  end;
end;

{ issues +CMGS to send message without placing the message in memory }
{$IFDEF AproBCB}
procedure TApdCustomGSMPhone.SendSMSMessage;
{$ELSE}
procedure TApdCustomGSMPhone.SendMessage;
{$ENDIF}
var
  Res : Integer;
  ET : EventTimer;
begin
  if FGSMState > gsNone then begin
    DoFail(secSMSBusy,-8100);
    Exit;
  end;
  if not FConnected then begin
    { Do connection/configuration stuff }
    Connect;
  end;
  if FNotifyOnNewMessage then                                            {!!.01}
    CmdIndex := 0                                                        {!!.01}
  else                                                                   {!!.01}
    CmdIndex := 1;
  ResponsePacket.EndString := #13;                                       {!!.01}
  ResponsePacket.StartString := GSMSendMessageResponse[CmdIndex];
  ResponsePacket.Enabled := True;
  //DelayTicks(4, True);                                                 {!!.04}
  SetState(gsSend);
  FComPort.Output := 'AT' + GSMSendMessageCommands[CmdIndex] + #13;
  NewTimer(ET, 1080); // 60 second timer
  repeat
    Res := SafeYield;
  until (FGSMState = gsNone) or (Res = wm_Quit) or TimerExpired(ET);
  if TimerExpired(ET) then begin
    DoFail(secSMSTimedOut,-8101);
    Exit;
  end;
end;

procedure TApdCustomGSMPhone.SetMessage(const Value: string);
begin
  if Length(Value) > 160 then begin
    DoFail(secSMSTooLong,-8102);
    Exit;
  end;
  FMessage := Value;
end;

{ enables/disables new message notification (+CNMI), new messages provided
  through OnNewMessage event }
procedure TApdCustomGSMPhone.SetNotifyOnNewMessage(const Value: Boolean);
begin
  FNotifyOnNewMessage := Value;
     // Return True for then +CMTI for New Message Indications to TE
end;

{ TApdMessageStore }
function TApdMessageStore.AddMessage(const Dest, Msg: string): Integer;
var
  SMS : TApdSMSMessage;
begin
  SMS := nil;
  try
    SMS := TApdSMSMessage.Create;
    SMS.Message := Msg;
    SMS.Address := Dest;
    SMS.TimeStampStr := FormatDateTime('yy/mm/dd/hh:mm:ss', Now);
    SMS.Status := ssUnsent;

    Result := AddObject(SMS.TimeStampStr, SMS);
  finally
    SMS.Free;
  end;
end;