gsmcom.pas

很好的手机发短信的例子。含GSM群发机设计原理和使用说明。还有详细代码

        Synchronize(UpdateDialTimeState);
        Application.ProcessMessages;
        Sleep(SLEEPTIME);
      end;
      FGSMSet.SendCount := FGSMSet.SendCount + 1;
      FGSMDialingTime := 0;
      Synchronize(UpdateHangupState);
      FApdGSMPhone.HangUp;
    end;
  except
    Result := false;
  end;
end;

function TGSMCom.DoMessage(WaitItem: TGSMMessageItem): Boolean;
var
  AMultiMessage:TMultiMessage;
  i: Integer;
begin
  FMSG := WaitItem.SMSMessage;
  FMobileNo := WaitItem.MobileNo;
  FApdGSMPhone.SMSAddress := FMobileNo;
  Synchronize(UpdateSendingState);
  Result := true;
  AMultiMessage := TMultiMessage.Create(WaitItem.SMSMessage);
  AMultiMessage.MessagLength := 70;
  for i:=0 to AMultiMessage.Count-1 do
  begin
    FApdGSMPhone.SMSAddress := WaitItem.MobileNo;
  if (FApdGSMPhone.SMSAddress[1]<>'8') and (FApdGSMPhone.SMSAddress[2]<>'6') then
    FApdGSMPhone.SMSAddress := '86'+Trim(FApdGSMPhone.SMSAddress);
    if FApdGSMPhone.GSMState = gsNone then
    begin
      FApdGSMPhone.SMSMessage := AMultiMessage.MSG[i];
      try
        FApdGSMPhone.SendMessage;
        Sleep(200);
      except
        Result := false;
//          break;
      end;
    end;
  end;
  AMultiMessage.Free;
end;

procedure TGSMCom.DoPause;
begin

end;


function TGSMCom.DoInitGSM: Boolean;
begin
  Synchronize(UpdateResetState);
  Result := false;
  try
    Synchronize(UpdateActiveState);
    InitGSMPhone;
  Except
    Result := true;
  end;
end;

procedure TGSMCom.UpdateDialState;
begin
  UpdateGSMComState(gaDial,FMobileNo,FMSG);
end;

procedure TGSMCom.UpdateHangupState;
begin
  UpdateGSMComState(gaHangUP,FMobileNo,FMSG);
end;

procedure TGSMCom.UpdateDialTimeState;
begin
  UpdateGSMComState(gaDialTime,FMobileNo,IntToStr(FGSMDialingTime));
end;

procedure TGSMCom.UpdateDialErrorState;
begin
  UpdateGSMComState(gaDialError,FMobileNo,'');
end;

{ TSendItems }

function TSendItems.AddFromSendItem(ASendItem: TGSMSendItem): TGSMSendItem;
begin
  Result := ASendItem;
  Add(ASendItem);
end;

constructor TSendItems.Create;
begin
  Inherited;
  FPosition := 0;
end;

procedure TSendItems.Delete(Index: Integer);
var
  AList: TList;
  AGSMSendItem: TGSMSendItem;
begin
  AList := LockList;
  AGSMSendItem := TGSMSendItem(AList.Items[Index]);
  AList.Remove(AGSMSendItem);
  AGSMSendItem.Free;
  UnlockList;
end;

procedure TSendItems.SetMSG(const Value: String);
begin
  FMSG := Value;
end;

procedure TSendItems.SetPosition(const Value: Integer);
begin
  FPosition := Value;
end;

{ TGSMTask }

constructor TGSMTask.Create(GSMTasks: TGSMTasks);
var
  GUID: TGUID;
begin
  FGSMTasks := GSMTasks;
  FTaskTime := now;
  FWaitSendItems := TSendItems.Create;
  FSendedItems := TSendItems.Create;
  FDataBaseInfo := TDataBaseInfo.Create;
  CreateGUID(GUID);
  FWaitCDSTName := Base32Encode(MD5(GUIDToString(GUID)));
  CreateGUID(GUID);
  FSendCDSTName := Base32Encode(MD5(GUIDToString(GUID)));
  FisFix := false;
  FSendedCount := 0;
end;

destructor TGSMTask.Destroy;
begin
  FDataBaseInfo.Free;
  FWaitSendItems.Free;
  FSendedItems.Free;
  inherited Destroy;
end;

procedure TGSMTask.SetFinished(const Value: Boolean);
begin
  FFinished := Value;
end;

procedure TGSMTask.SetInSequence(const Value: Boolean);
begin
  FInSequence := Value;
end;

procedure TGSMTask.SetSendedItems(const Value: TSendItems);
begin
  FSendedItems := Value;
end;

procedure TGSMTask.SetSMSMessage(const Value: String);
begin
  FSMSMessage := Value;
end;

procedure TGSMTask.SetTaskEndTime(const Value: TDateTime);
begin
  FTaskEndTime := Value;
end;

procedure TGSMTask.SetTaskName(const Value: String);
begin
  FTaskName := Value;
end;

procedure TGSMTask.SetTaskStartTime(const Value: TDateTime);
begin
  FTaskStartTime := Value;
end;

procedure TGSMTask.SetTaskTime(const Value: TDateTime);
begin
  FTaskTime := Value;
end;

procedure TGSMTask.SetWaitSendItems(const Value: TSendItems);
begin
  FWaitSendItems := Value;
end;

procedure TGSMTask.Start;
var
  GSMServer: TGSMServer;
begin
  if FGSMTasks.CurrentTask= nil then
  begin
    FStarted := true;
    FInSequence := true;
    FGSMTasks.CurrentTask := Self;
    FGSMTasks.RequestGSMServer(GSMServer);
  end
  else
  begin
    if FGSMTasks.CurrentTask<>self then
    begin
      FInSequence := true;
      FStarted := false;
    end
    else
    begin
      FStarted := true;
      FInSequence := true;
      FGSMTasks.CurrentTask := Self;
      FGSMTasks.RequestGSMServer(GSMServer);
    end;
  end;
end;


procedure TGSMTask.Stop;
var
  GSMServer: TGSMServer;
begin
  FStarted := false;
  FInSequence := False;
  FGSMTasks.CurrentTask := nil;
  FGSMTasks.RequestGSMServer(GSMServer);
  FGSMTasks.KillAllGSM;
  sleep(100);
  SaveSendedData;
  FGSMTasks.StartNextTask;
end;

function TGSMTask.GetWaitSendCount: Integer;
var
  AList: TList;
begin
  try
    AList := WaitSendItems.LockList;
    Result := AList.Count;
  finally
    WaitSendItems.UnlockList;
  end;
end;

procedure TGSMTask.SetDataBaseInfo(const Value: TDataBaseInfo);
begin
  FDataBaseInfo := Value;
end;

procedure TGSMTask.SetDynamicDataBase(const Value: boolean);
begin
  FDynamicDataBase := Value;
end;

procedure TGSMTask.SetUseDataBase(const Value: boolean);
begin
  FUseDataBase := Value;
end;

procedure TGSMTask.SaveSendedData;
var
  i:Integer;
  AList: TList;
  ASendItem: TGSMSendItem;
  TheSQL: String;
begin
{
  if FDynamicDataBase then
  begin
    AdoDataModule := TAdoDataModule.Create(nil);
    AdoDataModule.ADOConnection.ConnectionString := DataBaseInfo.ConnectionString;
    AdoDataModule.ADOConnection.Connected := true;
    AList := SendedItems.LockList;
    for i := SendedItems.Position to AList.Count-1 do
    begin
      ASendItem := TGSMSendItem(AList.Items[i]);
      if ASendItem<>nil then
      begin
        TheSQL := format('Update %s set %s=%d where %s=%s and %s=%d',
          [DataBaseInfo.TableName, DataBaseInfo.StateFieldName, 2,
          DataBaseInfo.KeyFieldName,ASendItem.KeyFieldValue,
          DataBaseInfo.StateFieldName, 1]);
        AdoDataModule.ADOCommand.CommandText := TheSQL;
        AdoDataModule.ADOCommand.Execute;
      end;
    end;
    SendedItems.Position := AList.Count;
    SendedItems.UnlockList;
    AdoDataModule.ADOConnection.Connected := false;
    AdoDataModule.Free;
  end;
}  
end;

procedure TGSMTask.SetSendCDSTName(const Value: String);
begin
  FSendCDSTName := Value;
end;

procedure TGSMTask.SetWaitCDSTName(const Value: String);
begin
  FWaitCDSTName := Value;
end;

function TGSMTask.GetSendedCount: Integer;
var
  AList: TList;
begin
{  try
    AList := SendedItems.LockList;
    Result := AList.Count;
  finally
    SendedItems.UnlockList;
  end;
}
  Result := FSendedCount;
end;

function TGSMTask.GetOneItem: TGSMSendItem;
var
  AList: TList;
  CCount: Integer;
  isEof: Boolean;
  PrepareCount: Integer;
  NewItem: TGSMSendItem;
begin
  Result := nil;
  CCount := 0;
  if WaitSendItems<>nil then
  try
    AList := WaitSendItems.LockList;
    CCount := AList.Count;
    if CCount>0 then
    begin
      FSendedCount := FSendedCount + 1;
      Result := TGSMSendItem(AList.First);
      if Result<>nil then
      begin
        case Result.GSMMode of
          gsmMessage:
            AList.Remove(Result);
          gsmDial:
          begin
            if TGSMDialItem(Result).isRepeat then
            begin
              if TGSMDialItem(Result).RepeatCount = -1 then
                Result := Result.Clone
              else if TGSMDialItem(Result).RepeatCount>1 then
              begin
                TGSMDialItem(Result).RepeatCount := TGSMDialItem(Result).RepeatCount -1;
                Result := Result.Clone
              end
              else if TGSMDialItem(Result).RepeatCount =1 then
                AList.Remove(Result);
            end
            else
              AList.Remove(Result);
          end;
        end;
      end;
    end;
  finally
    WaitSendItems.UnlockList;
  end;

end;

function TGSMTask.getIndex: Integer;
begin
  Result := FGSMTasks.IndexOf(self);
end;

procedure TGSMTask.SetisFix(const Value: Boolean);
begin
  FisFix := Value;
end;

procedure TGSMTask.SetDynamicText(const Value: Boolean);
begin
  FDynamicText := Value;
end;

procedure TGSMTask.SetReadLnCount(const Value: Integer);
begin
  FReadLnCount := Value;
end;


{ TGSMTasks }

function TGSMTasks.AddTask: TGSMTask;

begin
  Result := TGSMTask.Create(self);
  Add(Result);
end;

constructor TGSMTasks.Create(GSMServer: TGSMServer);
begin
  FGSMServer := GSMServer;
end;

function TGSMTasks.GetTask(Index: Integer): TGSMTask;
begin
  Result := nil;
  if (Index>=0) and (Index<Count) then
    Result := TGSMTask(Items[index]);

end;

procedure TGSMTasks.RequestGSMServer(var GSMServer: TGSMServer);
begin
  GSMServer := FGSMServer;
end;

procedure TGSMTasks.SetCurrentTask(const Value: TGSMTask);
begin
  FCurrentTask := Value;
end;

procedure TGSMTasks.SetTask(Index: Integer; const Value: TGSMTask);
begin

end;

procedure TGSMTasks.StartNextTask;
var
  i: Integer;
begin
  for i:= 0 to  Count-1 do
  begin
    if Task[i].InSequence then
    begin
      Task[i].Start;
      exit;
    end;
  end;
end;

procedure TGSMTasks.KillAllGSM;
begin
end;


procedure TGSMTasks.SaveToIniFile(IniFile: TIniFile);

  procedure SaveItemsToCDST(TheCDST: TClientDataSet; TheSendItems: TSendItems;
    FileName: String; TheTask: TGSMTask);
  var
    i: Integer;
    AList: TList;
    ASendItem: TGSMSendItem;
    exFileName: String;
  begin
    TheCDST.Active := true;
    TheCDST.EmptyDataSet;
    try
      AList := TheSendItems.LockList;
      for i:=0 to AList.Count-1 do
      begin
        TheCDST.Append;
        ASendItem := TGSMSendItem(AList.Items[i]);
        TheCDST.FieldValues['MobileNo'] := ASendItem.MobileNo;
        case ASendItem.GSMMode of
          gsmMessage:
          begin
            TheCDST.FieldValues['MSG'] := TGSMMessageItem(ASendItem).SMSMessage;
            TheCDST.FieldValues['GSMMode'] := 0;
          end;
          gsmDial:
          begin
            TheCDST.FieldValues['GSMMode'] := 1;
            TheCDST.FieldValues['isRepeat'] := TGSMDialItem(ASendItem).isRepeat;
            TheCDST.FieldValues['RepeatCount'] := TGSMDialItem(ASendItem).RepeatCount;
            TheCDST.FieldValues['DialTime'] := TGSMDialItem(ASendItem).DialTime;
          end;
        end;
        TheCDST.Post;
      end;
      exFileName := ExtractFilePath(Application.ExeName)+'Data\'+FileName+'.gst';
      TheCDST.SaveToFile(exFileName);
      TheSendItems.UnlockList;
    except
      TheSendItems.UnlockList;
    end;

  end;