Receber valores JavaScript complexos através de interface externa

Question

Eu estou tentando receber e potencialmente enviar valores complexos através TWebBrowser (usando TEmbeddedWB) com o objeto externo fornecido. Por exemplo; em javascript eu tentaria usar o método exposto com uma matriz como um parâmetro:

var test = [123, 'abc'];
external.someFunction(test);

//Or something more complex
var complexObject = {
  someMethod : function(){ return 1; },
  someProperty : 123,
  someArray : ['xyz', 3.14]
}
external.someFunction(complexObject);

Verificar o VarType de ambos os exemplos me diz que é um IDispatch.

function TSomeClass.someFunction(var Param : OleVariant) : OleVariant;
var
  vType : Integer;
begin
  vType := (VarType(Param) and VarTypeMask); //Says 9 (varDispatch)
  Result := true;
end;

Eu não estou completamente familiarizado com COM e eu não tenho certeza de como trabalhar com isso.

Qualquer ajuda seria apreciada.

Answer 1

Você pode tratar o objeto JScript, assim como qualquer outro objeto OleVariant COM. Existem algumas armadilhas em termos de matrizes (e praticamente qualquer objeto JScript é essencialmente uma matriz dispersa).

Depois de obter o objeto JScript em um OleVariant você pode simplesmente chamá-lo como faria com qualquer código normal (sem tempo de compilação verificação é claro).

Aqui está um código para lidar com matrizes:

type
  TJScriptArray = class
  private
    FArray:   IDispatchEx;
    FCount:   Integer;
    function  GetProperty( const AName: String ): OleVariant;
    function  GetItem(Index: Integer): OleVariant;
  public
    constructor Create( AObj: OleVariant );
    destructor  Destroy; override;
  public
    property  Count: Integer read FCount;
    property  Item[Index: Integer]: OleVariant read GetItem; default;
  end;

function  VarToDispatchEx( const AObject: OleVariant ): IDispatchEx;
begin
  Result := nil;
  if VarType( AObject ) <> varDispatch then
    Exit;
  Supports( IDispatch(AObject), IDispatchEx, Result );
end;

function  IsJScriptArray( const AObject: OleVariant ): Boolean;
var
  temp: IDispatchEx;
begin
  temp := VarToDispatchEx( AObject );
  Result := temp <> nil;
end;


constructor TJScriptArray.Create(AObj: OleVariant);
begin
  inherited Create;
  FArray := VarToDispatchEx( AObj );
  if FArray = nil then
    raise Exception.Create( 'TJscriptArray called with invalid parameters.' );
  FCount := GetProperty( 'length' );
end;

destructor TJScriptArray.Destroy;
begin
  inherited Destroy;
end;

function TJScriptArray.GetItem(Index: Integer): OleVariant;
begin
  if Index > FCount then
    raise Exception.Create( 'Index out of bounds.' );
  Result := GetProperty( IntToStr( Index ) );
end;

function TJScriptArray.GetProperty(const AName: String): OleVariant;
var
  sz: WideString;
  id: Integer;
  res: Variant;
  ei: TExcepInfo;
  params: TDispParams;
  hr: HResult;
begin
  {
    ACTION: return the specified property from the jscript array
    NOTE:   since a jscript array is a sparse array there may be
            gaps. In that case a null variant is returned. This is
            signalled by the name (id) not existing.
  }
  sz := AName;
  hr := FArray.GetDispID( PWideChar(sz), 0, id );
  if hr = disp_e_UnknownName then begin
    Result := Null;
    Exit;
    end
  else
    OleCheck( hr );

  VarClear( res );
  FillChar( ei, sizeof(ei), 0 );
  FillChar( params, sizeof(params), 0 );
  OleCheck( FArray.InvokeEx( id, 0, dispatch_PropertyGet, @params, @res, @ei, nil ) );
  Result := res;
end;

Answer 2

Embora eu não tenha diretamente feito o que você está tentando.

com uma Variant que puder você realmente métodos de acesso e propriedades dinamicamente.

Basicamente eu suspeito que você deve ser capaz de acessar tudo diretamente.

Param.Someproperty
Param.SomeArray[1]
Param.SomeMethod();

Você não terá erros de tempo de compilação se você conseguir as coisas erradas que deve ter cuidado.

Por exemplo, os seguintes compila o código, mas vai dar um erro de execução da operação variante inválida porque não há nada atribuídos dinamicamente para essa variável.

var
 vo : OleVariant;
 v  : Variant;
begin
  v.DoThis;
  vo.DoThat;
end;

Answer 3

Você já considerou a serialização de dados complexos usando JavaScript Object Notation (JSON)? Isso permitirá que você para serializar objetos arbitrários JavaScript, passá-los como uma seqüência de caracteres simples e reconstituí-los em código Delphi.

Delphi 2009 tem suporte para JSON como parte do novo DataSnap (não sei como é fácil utilização standalone). Há também uma série de implementações Delphi JSON lá fora, que pode ser útil:

lkjson e JSON - SuperObject

Não sou especialista em JSON, mas parece ser um relativamente simples e eficiente solução para intercâmbio de dados entre linguagens.

David

Answer 4

Objetos em Javascript são arrays associativos , com nomes de propriedades sendo chaves: obj.prop é equivalente a obj['prop']

.

matrizes regulares são simplesmente objetos armazenamento de índices como propriedades, para que eles se comportam como matrizes esparsas.

OleVariants da Delphi permitir o acesso direto às propriedades, mas apenas quando os seus nomes são válidos Delphi identificadores , por isso não gosta de usar um índice numérico como um nome de propriedade (ou seja obj.0 não compila).

As propriedades com nomes de identificadores inválidos podem ser lidos DISPATCH_PROPERTYGET invocando como em de Ryan resposta .

No entanto Delphi incluem rotinas adequadas em ComObjunit para diretamente fazer isso:

uses ComObj;

...

function TSomeClass.someFunction(var Param : OleVariant) : OleVariant;
begin
  ShowMessage(Param.someProperty); // 123
  ShowMessage(GetDispatchPropValue(Param, 'someProperty')); // 123

  ShowMessage(Param.someArray.length); // 2
  ShowMessage(GetDispatchPropValue(Param.someArray, '0')); // xyz

  Result := true;
end;