Vraag C # - Berichten verzenden naar Google Chrome vanuit de toepassing C #


Ik heb rondgekeken en ik heb niet ontdekt hoe ik dit zou doen met C #.

Ik wilde het zo maken dat ik Google Chrome kon laten gaan Vooruit, Terug, Open nieuw tabblad, Sluit Tab, Open een nieuw venster, en Venster sluiten van mijn C # -applicatie.

Ik deed iets soortgelijks met WinAmp gebruiken

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

en een paar anderen. Maar ik weet niet welk bericht moet worden verzonden of hoe ik kan vinden naar welk venster het moet worden doorgestuurd of zoiets.

Kan iemand me laten zien hoe ik die 6 opdrachten naar Chrome zou sturen vanuit C #? bedankt

BEWERK: Ok, ik word weggestemd, dus misschien was ik niet duidelijk genoeg, of mensen gaan ervan uit dat ik dit zelf niet heb proberen te achterhalen.

Ten eerste ben ik niet erg goed met de hele DllImport-dingen. Ik ben nog aan het leren hoe het allemaal werkt.

Ik vond een paar jaar geleden hetzelfde idee in Winamp en keek naar mijn code. Ik heb het gemaakt, zodat ik een nummer kon overslaan, teruggaan, spelen, pauzeren en winamp van mijn C # -code kon stoppen. Ik begon met het importeren van:

    [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);

Toen gebruikte ik de code die ik gebruikte om deze constanten te gebruiken voor de berichten die ik stuurde.

    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;

Ik zou de hwnd (het programma om het bericht naartoe te sturen) door:

IntPtr hwnd = FindWindow(m_windowName, null);

dan zou ik een bericht naar dat programma sturen:

SendMessageA(hwnd, WM_COMMAND, WA_STOP, WA_NOTHING);

Ik neem aan dat ik iets dergelijks zou doen voor Google Chrome. maar ik weet niet wat sommige van die waarden zouden moeten zijn, en ik googelde rond terwijl ik probeerde het antwoord te vinden, maar ik kon het niet, daarom vroeg ik hier. Dus mijn vraag is hoe krijg ik de waarden voor:

m_windowName en WM_COMMAND

en dan de waarden voor de verschillende commando's, vooruit, terug, nieuw tabblad, sluit Tab, nieuw raam, venster sluiten?


19
2017-09-29 08:25


oorsprong


antwoorden:


Begin met je onderzoek op http://dev.chromium.org/developers


BEWERK: Het verzenden van een bericht naar een venster is slechts de helft van het werk. Het venster moet op dat bericht reageren en dienovereenkomstig handelen. Als dat venster niets over een bericht weet of helemaal niets uitmaakt, hebt u geen kans om het te besturen door het verzenden van berichten in een venster.

U bekijkt een implementatiedetail over hoe Winamp op afstand wordt bestuurd. Het verzenden van berichten is slechts één manier om dit te doen en het is de manier waarop de Winamp-ontwikkelaars hebben gekozen. De berichten die u gebruikt, zijn door de gebruiker gedefinieerde berichten met een specifieke betekenis enkel en alleen naar Winamp.

Wat je moet doen in de eerste stap is om erachter te komen als Chromium ondersteunt een soort afstandsbediening en wat die mechanismen zijn.


9
2017-09-29 08:33



U kunt de naam van het venster gemakkelijk verkrijgen met Visual Studio's Spy ++ en op CTRL + F drukken en vervolgens chrome vinden. Ik probeerde het en kreeg

"Chrome_VistaFrame" voor het out-venster. Het daadwerkelijke venster met de webpagina in is "Chrome_RenderWidgetHostHWND".

Wat WM_COMMAND betreft, moet je experimenteren. U wilt natuurlijk klikken op knoppen (WM_MOUSEDOWN van de top van mijn hoofd). Omdat de back-forwardknoppen niet hun eigen vensters zijn, moet u weten hoe u dit moet doen door een muisklik te simuleren op een bepaalde x, y-positie, zodat chrome weet wat u doet. Of u kunt het sneltoets-equivalent verzenden voor heen / achteruit enzovoort.

Een voorbeeld dat ik een tijdje geleden schreef, doet dit met triljoen en winamp: berichten verzenden naar Windows via c # en winapi

Er zijn ook tools om dit soort dingen al te beschrijven, met behulp van een scriptingtaal - autoit is degene die ik heb gebruikt: autoit.com


7
2017-09-29 09:08



Ok, hier is wat ik tot nu toe heb ... Ik weet een beetje wat ik moet doen, maar het is gewoon een kwestie van het nu doen ...

Hier is het venster van Spy ++, ik sloot aan op de Chrome_RenderWidgetHostHWND en klikte op de knop Terug op mijn toetsenbord. Dit is wat ik heb: alt text

Dus dit zijn mijn aannames en ik speel hier nu voor altijd mee, ik kan er gewoon niet achter komen waarden.

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

Nu, ik weet gewoon niet wat ik moet doen de WM_KEYDOWN / UP-waarden of de VK_BROWSER_BACK / FORWARD-waarden ... Ik heb dit geprobeerd:

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

De laatste twee waarden die ik kreeg van de afbeelding die ik net liet zien, de ScanCodes voor die twee sleutels. Ik weet niet of ik het goed heb gedaan. De eerste twee waarden die ik kreeg nadat ik op Google naar de waarde WM_KEYDOWN had gezocht en iemand de waarden & H100 en & H101 voor de twee waarden heeft gebruikt. Ik heb verschillende andere willekeurige ideeën geprobeerd die ik heb gezien rondzweven. Ik kan er gewoon niet achter komen.

Oh, en hier is de SendMessage-methode

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

4
2017-09-29 18:59



Dit is een geweldige site voor interopconstanten:

Pinvoke

Een andere manier om de waarden te vinden, is om op koders.com te zoeken, met C # als taal, voor WM_KEYDOWN of de constante die u zoekt:

Koders.com zoeken

& H-waarden zien eruit als die van VB (6). pinvoke en koders geven beide resultaten voor 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;

(Het is grappig hoeveel onjuiste definities van VK-constanten rondzweven, aangezien VK_ * 1 byte 0-255 waarden zijn, en mensen ze uints hebben gemaakt).

Ziet er iets anders uit dan je consts. Ik denk dat de functie waarnaar je op zoek bent SendInput is (maar ik heb het niet geprobeerd) omdat het een virtuele sleutel is.

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

Uitleg over de parameters:

parameters

  • nInputs- Aantal structuren in de pInputs-array.
  • pInputs - Aanwijzer naar een array van INPUT-structuren. Elke structuur vertegenwoordigt een gebeurtenis die moet worden ingevoegd in de invoerstroom van het toetsenbord of de muis.
  • cbSize - Specificeert de grootte, in bytes, van een INPUT-structuur. Als cbSize niet de grootte heeft van een INPUT-structuur, mislukt de functie.

Dit heeft een KEYBOARD_INPUT-type nodig:

[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; 
}

En als laatste een voorbeeld, dat ik niet heb getest als het werkt:

/*
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]));
}

U moet ook het Chrome-venster gebruiken met SetForeGroundWindow


4
2017-09-30 09:25