Detalhes da API:

WinHttpGetIEProxyConfigForCurrentUser function

BOOL WINAPI WinHttpGetIEProxyConfigForCurrentUser(
  __inout  WINHTTP_CURRENT_USER_IE_PROXY_CONFIG *pProxyConfig
);

Como utilizá-la:

unit ProxyTest;

interface

uses
  Winapi.Windows, Vcl.Dialogs;

type
  PWinHttpCurrentUserIeProxyConfig = ^TWinHttpCurrentUserIeProxyConfig;

  TWinHttpGetIeProxyConfigForCurrentUser = function (pProxyConfig:
    PWinHttpCurrentUserIeProxyConfig): Boolean; stdcall;

  TWinHttpCurrentUserIeProxyConfig = record
    fAutoDetect: Boolean;
    lpszAutoConfigUrl: PWideChar;
    lpszProxy: PWideChar;
    lpszProxyBypass: PWideChar;
  end;

var
  WinHttpGetIeProxyConfigForCurrentUser: TWinHttpGetIeProxyConfigForCurrentUser;

procedure GetProxy;

implementation

procedure GetProxy;
var
  FHandle: THandle;
  FCurrentUser: PWinHttpCurrentUserIeProxyConfig;
begin
  FHandle := LoadLibrary('winhttp.dll');
  try
    if FHandle <> 0 then
    begin
      @WinHttpGetIeProxyConfigForCurrentUser := GetProcAddress(FHandle,
        'WinHttpGetIEProxyConfigForCurrentUser');

      if Assigned(WinHttpGetIeProxyConfigForCurrentUser) then
      begin
        WinHttpGetIeProxyConfigForCurrentUser(FCurrentUser);
        ShowMessage('Proxy: ' + FCurrentUser.lpszProxy);
      end;
    end;
  finally
    FreeLibrary(FHandle);
  end;
end;

end.

Desenvolvi o exemplo em Delphi XE2, qualquer dúvida é só entrar em contato.

A função desenvolvida utiliza a JEDI Windows API, que você pode obter aqui.

unit WTSControl;

interface

uses
  Classes,
  JwaWinsock2,
  JwaWinType,
  JwaWtsApi32,
  SysUtils;

type
  TWTSSession = record
    ClientIP: string;
    Session: Integer;
  end;

  TWTSSessionArray = array of TWTSSession;
  PWtsSessionInfoAArray = ^TWtsSessionInfoAArray;
  TWtsSessionInfoAArray = array [0 .. ANYSIZE_ARRAY - 1] of WTS_SESSION_INFOA;

function GetClientIP(const Server: string): TWTSSessionArray;

implementation

function GetClientIP(const Server: string): TWTSSessionArray;
var
  ASession: PWtsSessionInfoAArray;
  FBytes: Cardinal;
  FClientAdd: PWtsClientAddress;
  FHandle: THandle;
  FIP: string;
  I: Cardinal;
  X: Integer;
begin
  if Trim(Server) = '' then
    FHandle := WTS_CURRENT_SERVER
  else
    FHandle := WTSOpenServer(PChar(Server));

  if WTSEnumerateSessions(FHandle, 0, 1, PWTS_SESSION_INFO(ASession), I) then
  begin
    SetLength(Result, I);

    for X := 0 to I - 1 do
    begin
      WTSQuerySessionInformation(FHandle, ASession^[X].SessionId,
        WTSClientAddress, Pointer(FClientAdd), FBytes);

      case FClientAdd^.AddressFamily of
        AF_INET:
          begin
            FIP := Format('%d.%d.%d.%d', [FClientAdd^.Address[2],
              FClientAdd^.Address[3], FClientAdd^.Address[4],
              FClientAdd^.Address[5]]);
          end;
        AF_INET6:
          begin
            FIP := 'IPv6 address not yet supported';
          end;
        AF_IPX:
          begin
            FIP := 'IPX is not supported';
          end;
        AF_NETBIOS:
          begin
            FIP := 'NETBIOS is not supported';
          end;
        AF_UNSPEC:
          begin
            FIP := 'Console and listener session have no address';
          end;
      end;
      Result[X].ClientIP := FIP;
      Result[X].Session := ASession^[X].SessionId;
      WTSFreeMemory(FClientAdd);
    end;
  end;
end;

end.

Criei o record TWTSSession para retornar um array, definido como TWTSSessionArray, de todas as sessões existentes no servidor Terminal Service. Segue abaixo um exemplo de utilização:

procedure Executar;
var
  AWTS: TWTSSessionArray;
  FCount: Integer;
begin
  AWTS := GetClientIP('');
  for FCount := Low(AWTS) to High(AWTS) do
  begin
    ShowMessage('Session: ' + FormatFloat('00000', AWTS[FCount].Session) +
      ' IP: ' + AWTS[FCount].ClientIP);
  end;
end;

O download do código-fonte pode ser feito aqui.

Você inicia esse processo, mas, no meio da execução, ele é interrompido. Seu Windows entrou em hibernação após um determinado tempo. Infelizmente todo o seu trabalho acabou atrasando um dia, pois terá que ser executado no dia seguinte.

Esse é um exemplo banal mas que acontece muito no cotidiano dos profissionais de TI. Para não dependermos de configurações externas, podemos utilizar a própria API do Windows, utilizando a função SetThreadExecutionState e tornando o nosso software mais inteligente e evitando assim surpresas desagradáveis! 

Vejam a classe desenvolvida abaixo. Através dela, conseguimos proteger qualquer rotina que seja critica enquanto estiver em execução.

unit CriticalProcess;

interface

type
  TCriticalProcess = class
  protected
    procedure Execute(const Value: Boolean); virtual;
  public
    constructor Create;
    destructor Destroy; override;

    procedure Stop;
    procedure Start;
  end;

var
  CriticalProcess: TCriticalProcess;

implementation

uses
  Windows;

type
  EXECUTION_STATE = DWORD;

const
  ES_CONTINUOUS      = $80000000;
  ES_SYSTEM_REQUIRED = $00000001;

procedure SetThreadExecutionState(ESFlags: EXECUTION_STATE); stdcall;
  external kernel32 name 'SetThreadExecutionState';

constructor TCriticalProcess.Create;
begin
  inherited;

end;

destructor TCriticalProcess.Destroy;
begin

  inherited;
end;

procedure TCriticalProcess.Stop;
begin
  Execute(False);
end;

procedure TCriticalProcess.Start;
begin
  Execute(True);
end;

procedure TCriticalProcess.Execute(const Value: Boolean);
begin
  if Value then
    SetThreadExecutionState(ES_SYSTEM_REQUIRED or ES_CONTINUOUS)
  else
    SetThreadExecutionState(ES_CONTINUOUS);
end;

initialization
  CriticalProcess := TCriticalProcess.Create;

finalization
  CriticalProcess.Free;

end.

Exemplo de utilização da classe:

uses
  CriticalProcess;

procedure TfrmExemplo.btnExecutarClick(Sender: TObject);
begin
  CriticalProcess.Start;
  try
    // Coloque aqui todo o processamento crítico.

    // Todo o bloco de código inserido aqui estará protegido
    // e será executado sem interferências do sistema operacional.

  finally
    CriticalProcess.Stop;
  end;
end;

Toda a documentação sobre o método SetThreadExecutionState é encontrado no site da Microsoft.

A CBO é o documento que reconhece, nomeia e codifica os títulos e descreve as características das ocupações do mercado de trabalho brasileiro. Sua atualização e modernização se devem às profundas mudanças ocorridas no cenário cultural, econômico e social do País nos últimos anos, implicando alterações estruturais no mercado de trabalho.

A nova versão contém as ocupações do mercado brasileiro, organizadas e descritas por famílias. Cada família constitui um conjunto de ocupações similares correspondente a um domínio de trabalho mais amplo que aquele da ocupação.

Criada em 1982 e somente com alterações pontuais (não foi modificada a estrutura inicial), a classificação brasileira de ocupações (CBO 2002) substitui a versão lançada em 1994.

A Classificação Brasileira de Ocupações (CBO 2002) é fornecida gratuitamente em formato PDF pelo site do Ministério do Trabalho, mas resolvi compartilhar com vocês em um formato mais acessível para quem trabalha com desenvolvimento de sistemas.

Clique aqui para fazer download do banco de dados CBO 2002 em formato Microsoft Access (não que eu trabalhe com Access, mas acredito que seja mais fácil a migração para outros formatos).

unit ApplicationSession;

interface

uses
  Windows, Forms;

type
  TApplicationSession = class
  private
    FHandle: THandle;
  public
    constructor Create(const Handle: THandle);
    destructor Destroy; override;
  end;

var
  ApplicationSession: TApplicationSession;

implementation

constructor TApplicationSession.Create(const Handle: THandle);
begin
  FHandle := Handle;

  if GlobalFindAtom(PChar(Application.Title)) = 0 then
  begin
    FHandle := GlobalAddAtom(PChar(Application.Title));
  end
  else
  begin
    Application.MessageBox('This process is already running.',
      PChar(Application.Title), MB_OK + MB_ICONSTOP);
    Application.Terminate;
  end;
end;

destructor TApplicationSession.Destroy;
begin
  GlobalDeleteAtom(FHandle);

  inherited;
end;

initialization
  ApplicationSession := TApplicationSession.Create(Application.Handle);

finalization
  ApplicationSession.Free;

end.

Para utilizá-la basta adicionar a unit no seu arquivo de projeto, como o exemplo abaixo:

program SessionExample;

uses
  ApplicationSession in 'ApplicationSession.pas',
  Forms,
  FSessionExample in 'FSessionExample.pas' {frmSessionExample};

{$R *.res}

begin
  Application.Initialize;
  Application.MainFormOnTaskbar := True;
  Application.Title := 'Session Example';
  Application.CreateForm(TfrmSessionExample, frmSessionExample);
  Application.Run;
end.

Se o usuário tentar executar o mesmo aplicativo com uma cópia já em execução a mensagem “This process is already running.” é apresentada.

Após isso o aplicativo será finalizado.

Lembrando que você pode personalizar como quiser essa rotina, como por exemplo a mensagem, que está em inglês, apenas edite o construtor da classe.

Utilizando a rotina abaixo, podemos verificar se nossa aplicação está sendo executada ou não remotamente e, se necessário, fazer adaptações no sistema para definir a exibição/ausência de recursos.

function InTerminalService: Boolean;
const
  sm_RemoteSession = $1000;
begin
  Result := GetSystemMetrics(sm_RemoteSession) <> 0;
end;

Sempre mantive material técnico em meus blogs, desta vez resolvi mesclar assuntos que vivencio no meu dia-a-dia, entre desenvolvimento de software, games, bodybuilding e até aquariofilismo, enfim, tudo o que eu gosto.

Esse tema é otimizado para acesso em iPad e smartphones, além de utilizar algumas API’s do Google, que eu adaptei para melhor visualização.

Espero que esse seja meu último “Hello world!”.