C #: invio di messaggi a Google Chrome dall'applicazione C #

StackOverflow https://stackoverflow.com/questions/147929

  •  02-07-2019
  •  | 
  •  

Domanda

Ho cercato in giro e non ho trovato come farei da C #.

Volevo farlo in modo da poter dire a Google Chrome di andare Avanti , Indietro , Apri nuova scheda , Chiudi Scheda , Apri nuova finestra e Chiudi finestra dalla mia applicazione C #.

Ho fatto qualcosa di simile con WinAmp usando 

[DllImport("user32", EntryPoint = "SendMessageA")]
private static extern int SendMessage(int Hwnd, int wMsg, int wParam, int lParam);

e pochi altri. Ma non so a quale messaggio inviare o come trovare a quale finestra passarlo o altro.

Quindi qualcuno potrebbe mostrarmi come avrei inviato quei 6 comandi a Chrome da C #? grazie

EDIT: Ok, sto per essere votato verso il basso, quindi forse non sono stato abbastanza chiaro, o la gente presume che non abbia provato a capirlo da solo.

Prima di tutto, non sono molto bravo con l'intera roba di DllImport. Sto ancora imparando come funziona.

Ho scoperto come fare la stessa idea in Winamp qualche anno fa e stavo guardando il mio codice. L'ho fatto in modo da poter saltare una canzone, tornare indietro, riprodurre, mettere in pausa e interrompere Winamp dal mio codice C #. Ho iniziato importando: 

    [DllImport("user32.dll", CharSet = CharSet.Auto)]
    public static extern IntPtr FindWindow([MarshalAs(UnmanagedType.LPTStr)] string lpClassName, [MarshalAs(UnmanagedType.LPTStr)] string lpWindowName);
    [DllImport("user32.dll", CharSet = CharSet.Auto)]
    static extern int SendMessageA(IntPtr hwnd, int wMsg, int wParam, uint lParam);
    [DllImport("user32.dll", CharSet = System.Runtime.InteropServices.CharSet.Auto)]
    public static extern int GetWindowText(IntPtr hwnd, string lpString, int cch);
    [DllImport("user32", EntryPoint = "FindWindowExA")]
    private static extern int FindWindowEx(int hWnd1, int hWnd2, string lpsz1, string lpsz2);
    [DllImport("user32", EntryPoint = "SendMessageA")]
    private static extern int SendMessage(int Hwnd, int wMsg, int wParam, int lParam);

Quindi il codice che ho trovato per usare questo ha usato queste costanti per i messaggi che invio. 

    const int WM_COMMAND = 0x111;
    const int WA_NOTHING = 0;
    const int WA_PREVTRACK = 40044;
    const int WA_PLAY = 40045;
    const int WA_PAUSE = 40046;
    const int WA_STOP = 40047;
    const int WA_NEXTTRACK = 40048;
    const int WA_VOLUMEUP = 40058;
    const int WA_VOLUMEDOWN = 40059;
    const int WINAMP_FFWD5S = 40060;
    const int WINAMP_REW5S = 40061;

Vorrei ottenere hwnd (il programma a cui inviare il messaggio) di: 

IntPtr hwnd = FindWindow(m_windowName, null);

quindi invierei un messaggio a quel programma: 

SendMessageA(hwnd, WM_COMMAND, WA_STOP, WA_NOTHING);

Presumo che farei qualcosa di molto simile a questo per Google Chrome. ma non so quali dovrebbero essere alcuni di questi valori e ho cercato su Google di cercare la risposta, ma non ci sono riuscito, motivo per cui ho chiesto qui. Quindi la mia domanda è come posso ottenere i valori per:

m_windowName e WM_COMMAND

e quindi, i valori per i diversi comandi, avanti , indietro , nuova scheda , chiudi scheda , nuova finestra , chiudi finestra ?

È stato utile?

Soluzione

Inizia la tua ricerca su http://dev.chromium.org/developers

MODIFICA : l'invio di un messaggio a una finestra è solo metà del lavoro. La finestra deve rispondere a quel messaggio e agire di conseguenza. Se quella finestra non è a conoscenza di un messaggio o non ti interessa affatto, non hai alcuna possibilità di controllarlo inviando messaggi per finestre.

Stai guardando un dettaglio dell'implementazione su come hai controllato a distanza Winamp. L'invio di messaggi è solo un modo per farlo ed è il modo scelto dagli sviluppatori di Winamp. Quei messaggi che stai usando sono messaggi definiti dall'utente che hanno un significato specifico solo per Winamp.

Quello che devi fare nel primo passo è scoprire se Chromium supporta un qualche tipo di controllo remoto e quali sono questi meccanismi.

Altri suggerimenti

Puoi ottenere facilmente il nome della finestra usando Spy ++ di Visual Studio e premendo CTRL + F, quindi trovando Chrome. L'ho provato e ho

" Chrome_VistaFrame " per la finestra esterna. La finestra effettiva con la pagina web è " Chrome_RenderWidgetHostHWND " ;.

Per quanto riguarda WM_COMMAND, dovrai sperimentare. Ovviamente vorrai inviare i clic sui pulsanti (WM_MOUSEDOWN della parte superiore della mia testa). Dato che i pulsanti avanti e indietro non sono finestre proprie, dovrai capire come farlo simulando un clic del mouse in una determinata posizione x, y in modo che Chrome sappia cosa stai facendo. Oppure potresti inviare l'equivalente della scorciatoia da tastiera per avanti / indietro e così via.

Un esempio che ho scritto qualche tempo fa fa ciò con trillian e winamp: invio di messaggi su windows tramite c # e winapi

Ci sono anche strumenti là fuori per fare questo tipo di cose, usando un linguaggio di scripting: autoit è quello che ho usato: autoit.com

Ok, ecco cosa ho fatto finora ... So che cosa devo fare, ma è solo una questione di farlo ora ...

Ecco la finestra di Spy ++, ho bloccato Chrome_RenderWidgetHostHWND e ho fatto clic sul pulsante Indietro sulla mia tastiera. Ecco cosa ho ottenuto: alt text

Quindi ecco i miei presupposti, e ci sto giocando da sempre ormai, non riesco proprio a capire i valori . 

IntPtr hWnd = FindWindow("Chrome_RenderWidgetHostHWND", null);
SendMessage(hWnd, WM_KEYDOWN, VK_BROWSER_BACK, 0);
SendMessage(hWnd, WM_KEYUP,   VK_BROWSER_BACK, 0);

Ora, non so proprio cosa dovrei creare i valori WM_KEYDOWN / UP o i valori VK_BROWSER_BACK / FORWARD ... Ho provato questo: 

const int WM_KEYDOWN = 0x100;
const int WM_KEYUP = 0x101;
const int VK_BROWSER_BACK = 0x6A;
const int VK_BROWSER_FORWARD = 0x69;

Gli ultimi due valori che ho ottenuto dall'immagine che ho appena mostrato, i ScanCodes per quelle due chiavi. Non so se l'ho fatto bene però. I primi due valori che ho ottenuto dopo aver cercato su Google il valore WM_KEYDOWN e qualcuno ha usato & amp; H100 e & amp; H101 per i due valori. Ho provato diverse altre idee casuali che ho visto fluttuare in giro. Non riesco proprio a capirlo.

Oh, ed ecco il metodo SendMessage 

    [DllImport("user32.dll", CharSet = CharSet.Auto)]
    static extern int SendMessage(IntPtr hwnd, int wMsg, int wParam, uint lParam);

Questo è un ottimo sito per le costanti di interoperabilità:

pinvoke

Un altro modo per trovare i valori è cercare koders.com, usando C # come lingua, per WM_KEYDOWN o la costante che stai cercando:

Koders.com > I valori

??& amp; H sembrano simili a quelli di VB (6). pinvoke e koders restituiscono entrambi risultati per VK_BROWSER_FORWARD, 

private const UInt32 WM_KEYDOWN        = 0x0100;
private const UInt32 WM_KEYUP          = 0x0101;

public const ushort VK_BROWSER_BACK = 0xA6;
public const ushort VK_BROWSER_FORWARD = 0xA7;
public const ushort VK_BROWSER_REFRESH = 0xA8;
public const ushort VK_BROWSER_STOP = 0xA9;
public const ushort VK_BROWSER_SEARCH = 0xAA;
public const ushort VK_BROWSER_FAVORITES = 0xAB;
public const ushort VK_BROWSER_HOME = 0xAC;

(È buffo quante definizioni errate delle costanti VK stanno fluttuando, considerando che VK_ * sono valori di 0-255 byte 1 e le persone li hanno fatti uint).

Sembra leggermente diverso dai tuoi contro. Penso che la funzione che stai cercando sia SendInput (ma non l'ho provato) in quanto è una chiave virtuale. 

[DllImport("User32.dll")]
private static extern uint SendInput(uint numberOfInputs, [MarshalAs(UnmanagedType.LPArray, SizeConst = 1)] KEYBOARD_INPUT[] input, int structSize);

Spiegazione sui parametri:

I parametri

  • nInputs: numero di strutture nell'array pInputs.
  • pInputs - Puntatore a una matrice di strutture INPUT. Ogni struttura rappresenta un evento da inserire nel flusso di input della tastiera o del mouse.
  • cbSize - Specifica la dimensione, in byte, di una struttura INPUT. Se cbSize non ha le dimensioni di una struttura INPUT, la funzione ha esito negativo.

Questo richiede un tipo KEYBOARD_INPUT: 

[StructLayout(LayoutKind.Sequential)] 
public struct KEYBOARD_INPUT
{ 
    public uint type; 
    public ushort vk; 
    public ushort scanCode; 
    public uint flags; 
    public uint time; 
    public uint extrainfo; 
    public uint padding1; 
    public uint padding2; 
}

E infine un campione, che non ho testato se funziona: 

/*
typedef struct tagKEYBDINPUT {
    WORD wVk;
    WORD wScan;
    DWORD dwFlags;
    DWORD time;
    ULONG_PTR dwExtraInfo;
} KEYBDINPUT, *PKEYBDINPUT;
*/
public static void sendKey(int scanCode, bool press)
{
        KEYBOARD_INPUT[] input = new KEYBOARD_INPUT[1];
        input[0] = new KEYBOARD_INPUT();
        input[0].type = INPUT_KEYBOARD;
        input[0].vk = VK_BROWSER_BACK;

    uint result = SendInput(1, input, Marshal.SizeOf(input[0]));
}

Inoltre dovrai focalizzare la finestra di Chrome usando SetForegroundWindow

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top