JNA का उपयोग करके वैश्विक कीस्ट्रोक्स पंजीकृत करें

नमस्कार, इस लेख में मैं आपको बताऊंगा कि जावा, विंडोज, लिनक्स, बीएसडी और मैक ओएसएक्स के तहत जावा से वैश्विक कीस्ट्रोक्स कैसे पंजीकृत करें, जो कि उत्कृष्ट जेएनए लाइब्रेरी का उपयोग कर रहे हैं।

JNA किसके लिए है?

जावा डेस्कटॉप के साथ दोस्त बनाना मुश्किल है, कुछ चीजों के लिए आपको ऑपरेटिंग सिस्टम के साथ बातचीत करने के लिए पुलों को लिखना होगा। इनमें से एक विशेषता वैश्विक हॉटकीज़ है, जो ऑडियो खिलाड़ियों में बहुत लोकप्रिय है, जब एक छिपे हुए राज्य में भी कुछ कीबोर्ड शॉर्टकट या मीडिया बटन का उपयोग करके कार्यक्रम को नियंत्रित किया जा सकता है। जेएनए बचाव में आता है - देशी पुस्तकालयों को कॉल करने के लिए जेनी और लिबफी पर एक ऐड, यह लगभग सभी लोकप्रिय प्लेटफार्मों का समर्थन करता है, लंबे समय से विकसित किया गया है और बहुत स्थिर है।

सभी प्लेटफार्मों के लिए जावा के लिए पहले से ही कई स्थिर पुस्तकालय हैं: विंडोज के लिए JIntelliType , जो मीडिया बटन, लिनक्स सिस्टम के लिए JXGrabKey और मैक OSX के लिए ossuport- कनेक्टर का भी समर्थन करता है। हालांकि, वे सभी जेनी का उपयोग करते हैं, एक अलग इंटरफ़ेस रखते हैं, और जेनी पर पुस्तकालयों के साथ काम करना हमेशा सुविधाजनक नहीं होता है, क्योंकि आपको देशी पुस्तकालयों के लिए पथ पंजीकृत करने की आवश्यकता होती है, सिस्टम क्षमता आदि से निपटना होगा, प्लस, यह शाही सेना का उपयोग करने में एक दिलचस्प अभ्यास होगा, क्योंकि यह कार्य पूरी तरह से प्रयास की एक छोटी राशि के साथ जावा में पूरी तरह से किया जा सकता है और आसानी से समर्थित क्रॉस-प्लेटफॉर्म कोड प्राप्त कर सकते हैं।

विंडोज

विंडोज पर वैश्विक हॉटकी के साथ काम करने का सबसे आसान तरीका है:

सार्वजनिक वर्ग User32 {
स्थिर {
मूल निवासी। रजिस्टर ( NativeLibrary। getInstance ( "user32" , W32APIOptions। DEFAULT_OPTIONS ) ) ;
}

सार्वजनिक स्थिर अंतिम int MOD_ALT = 0x0001 ;
सार्वजनिक स्थिर अंतिम int MOD_CONTROL = 0x0002 ;
सार्वजनिक स्थिर अंतिम int MOD_SHIFT = 0x0004 ;
सार्वजनिक स्थिर अंतिम int MOD_WIN = 0x0008 ;
सार्वजनिक स्थिर अंतिम इंट WM_HOTKEY = 0x0312 ;

सार्वजनिक स्थैतिक देशी बूलियन रजिस्टरहॉटके ( पॉइंटर hWnd, int id, int fsModifiers, intk pk ) ;
सार्वजनिक स्थिर देशी बूलियन UnregisterHotKey ( पॉइंटर hWnd, इंट आईडी ) ;
सार्वजनिक स्थिर देशी बूलियन PeekMessage ( MSG lpMsg, Pointer hWnd, int wMsgFilterMin, int wMsgFilterMax, int wRemoveMsg ) ;

सार्वजनिक स्थैतिक वर्ग MSG का विस्तार
सार्वजनिक सूचक hWnd ;
सार्वजनिक इंट संदेश ;
सार्वजनिक int wParam ;
सार्वजनिक int lParam ;
सार्वजनिक इंट टाइम ;
सार्वजनिक int x ;
पब्लिक इंट वाई ;
}
}

यहां हम तथाकथित डायरेक्ट मैपिंग का उपयोग करते हैं। इस तथ्य के अलावा कि यह तेज है, इसके साथ काम करना आसान है, क्योंकि आप स्थैतिक आयात कर सकते हैं और देशी के रूप में विधियों का उपयोग कर सकते हैं। हमें User32 से तीन विधियों की आवश्यकता है:

• RegisterHotKey - वास्तव में एक हॉटकी पंजीकृत करें। पहला पैरामीटर शून्य करने के लिए सेट किया जा सकता है, क्योंकि हमारे पास एक खिड़की नहीं है। दूसरा पैरामीटर - हमारे हॉटकी की अद्वितीय संख्या, हमारे द्वारा बनाई गई है, इसका उपयोग तब हॉटकी की पहचान करने और UnregisterHotKey के माध्यम से इसे हटाने के लिए किया जाएगा। FsModifiers में हम लिखते हैं कि हमें किस संशोधक की आवश्यकता है (ctrl, shift, alt या win)। Vk में हम वर्चुअल कोड लिखते हैं। दिलचस्प है, AWT में KeyEvent में उपयोग किए जाने वाले वर्चुअल कोड लगभग हमेशा विंडोज में वर्चुअल कोड के साथ मेल खाते हैं:
  
  

  // संयोजन जीत + एफ रजिस्टर
  RegisterHotKey ( शून्य , 1 , 0x8, KeyEvent । VK_F ) ;

  
  
• PeekMessage - आने वाले संदेशों की जाँच करता है और उन्हें MSG संरचना में बंद कर देता है। यहां, एक गैर-अवरुद्ध PeekMessage कॉल का उपयोग अवरुद्ध GetMessage के बजाय किया जाता है क्योंकि सभी विधियों को एक ही थ्रेड से कॉल किया जाना चाहिए और हमें इस थ्रेड को नियंत्रित करने में सक्षम होने की आवश्यकता है:
  

  MSG संदेश = नया MSG ( ) ;
  जबकि ( सुनो ) {
  जबकि ( PeekMessage ( संदेश, अशक्त , 0 , 0 , PM_REMOVE ) ) {
  अगर ( संदेश। == WM_HOTKEY ) {
  प्रणाली। बाहर । Println ( "Yattaaaa। Hotkey with id" + msg। wParam ) ;
  }
  }
  
  थ्रेड। नींद ( 300 ) ;
  }

  
  यहां हम जीत + एफ संयोजन को पंजीकृत करते हैं और हर 300 एमएस पर संदेशों की जांच करते हैं।

X11

दुर्भाग्य से, आप X11 के लिए डायरेक्ट मैपिंग का उपयोग नहीं कर सकते हैं, क्योंकि किसी कारण से यह FreeBSD के साथ काम करते समय त्रुटियों का कारण बनता है। मानचित्रण थोड़ा और जटिल लगता है:

सार्वजनिक इंटरफ़ेस X11 लाइब्रेरी फैली {
सार्वजनिक स्थिर X11 Lib = ( X11 ) मूल । loadLibrary ( "X11" , X11। वर्ग ) ;
सार्वजनिक स्थिर अंतिम int GrabModeAsync = 1 ;
सार्वजनिक स्थिर अंतिम int KeyPress = 2 ;

सार्वजनिक स्थिर अंतिम int ShiftMask = ( 1 ) ;
सार्वजनिक स्थिर अंतिम int LockMask = ( 1 << 1 ) ;
सार्वजनिक स्थिर अंतिम int ControlMask = ( 1 << 2 ) ;
सार्वजनिक स्थिर अंतिम int Mod1Mask = ( 1 << 3 ) ;
सार्वजनिक स्थिर अंतिम int Mod2Mask = ( 1 << 4 ) ;
सार्वजनिक स्थिर अंतिम int Mod3Mask = ( 1 << 5 ) ;
सार्वजनिक स्थिर अंतिम int Mod4Mask = ( 1 << 6 ) ;
सार्वजनिक स्थिर अंतिम int Mod5Mask = ( 1 << 7 ) ;

सार्वजनिक सूचक XOpenDisplay ( स्ट्रिंग नाम ) ;
सार्वजनिक NativeLong XDefaultRootWindow ( सूचक प्रदर्शन ) ;
सार्वजनिक बाइट XKeysymToKeycode ( पॉइंटर डिस्प्ले, लॉन्ग कीसम ) ;
सार्वजनिक int XGrabKey ( पॉइंटर डिस्प्ले, int code, int modifiers, NativeLong root, int ownerEvents, int pointerMode, int keyBoardMode ) ;
सार्वजनिक int XUngrabKey ( पॉइंटर डिस्प्ले, इंट कोड, इंट संशोधक, मूल निवासी रूट ) ;
सार्वजनिक int XNextEvent ( सूचक प्रदर्शन, XEvent घटना ) ;
सार्वजनिक int XPending ( पॉइंटर डिस्प्ले ) ;
सार्वजनिक int XCloseDisplay ( सूचक प्रदर्शन ) ;

सार्वजनिक स्थैतिक वर्ग XEvent संघ {
सार्वजनिक इंट प्रकार ;
सार्वजनिक XKeyEvent xkey ;
सार्वजनिक NativeLong [ ] पैड = नया NativeLong [ 24 ] ;
}

सार्वजनिक स्थिर वर्ग XKeyEvent का विस्तार
सार्वजनिक इंट प्रकार ; // घटना की
सार्वजनिक NativeLong धारावाहिक ; // # सर्वर द्वारा संसाधित अंतिम अनुरोध का
सार्वजनिक int send_event ; // सच है अगर यह SendEvent अनुरोध से आया है
सार्वजनिक सूचक प्रदर्शन ; // सार्वजनिक प्रदर्शन घटना से पढ़ा गया था
सार्वजनिक NativeLong विंडो ; // "घटना" विंडो के सापेक्ष इसकी सूचना दी जाती है
सार्वजनिक NativeLong जड़ ; // रूट विंडो जिस पर ईवेंट हुआ
सार्वजनिक नेटिव्लॉन्ग सबविंडो ; // बच्चे की खिड़की
सार्वजनिक NativeLong समय ; // मिलीसेकंड
सार्वजनिक int x, y ; // पॉइंटर x, y ईवेंट विंडो में समन्वय करता है
सार्वजनिक int x_root, y_root ; // रूट के सापेक्ष निर्देशांक
सार्वजनिक इंट राज्य ; // कुंजी या बटन मुखौटा
सार्वजनिक इंट कीकोड ; // विस्तार
सार्वजनिक int same_screen ; // वही स्क्रीन फ्लैग
}
}

• XOpenDisplay, XCloseDisplay, XDefaultRootWindow - डिफ़ॉल्ट डिस्प्ले और रूट विंडो को प्राप्त करें और बंद करें।
• XKeysymToKeycode - एक वर्ण को परिवर्तित करता है (वर्णों के वर्णनों को कीबोर्ड कोड में लिया जाता है), इसे बाद में आवश्यकता होगी:
  

  // अक्षरों और संख्याओं के लिए, वर्ण संख्या KeyEvent में मूल्य से भी मेल खाती है
  बाइट कोड = XKeysymToKeycode ( प्रदर्शन, KeyEvent । VK_F ) ;
  

• XGrabKey, XUngrabKey - रजिस्टर करें और हॉटकीज को हटा दें। कोड में, यहाँ XKeysymToKeycode के साथ पहले प्राप्त मूल्य लिखा गया है, संशोधक संशोधक में लिखे गए हैं, जड़ में XDefaultRootWindow से मान है। शेष मान इकाइयों के साथ भरा हुआ है। दिलचस्प बात यह है कि X11 में, दबाए गए स्क्रॉललॉक, न्यूमॉक, कैप्सलॉक और कुछ अन्य लॉक को भी संशोधक माना जाता है, इसलिए एक हॉटकी के बजाय आपको प्रत्येक संभावित संयोजन के लिए 16 पंजीकृत करना होगा:
  

  // यह हैक डेडबीफ प्लेयर में ग्लोबल हॉटकी प्लगइन में पाया जाता है
  के लिए ( झंडे = 0 ; झंडे < 16 ; मैं ++ ) {
  int ret = संशोधक ;
  अगर ( झंडे और 1 ) ! = 0 )
  रिट ; = लॉकमास्क ;
  अगर ( झंडे और 2 ) ! = 0 )
  रिट । = Mod2Mask ;
  अगर ( झंडे और 4 ) ! = 0 )
  रिट । = Mod3Mask ;
  अगर ( झंडे और 8 ) ! = 0 )
  रिट । = Mod5Mask ;
  XGrabKey ( प्रदर्शन, कोड, रिट, रूट, 1 , GrabModeAsync, GrabModeAsync ) ;
  // XUngrabKey (प्रदर्शन, कोड, रिट, रूट);
  }
  

  
  इसके अलावा, विंडोज के विपरीत, जहां प्रोग्राम से बाहर निकलने पर हॉटकी हटाना आवश्यक नहीं है, यदि आप XUngrabKey को कॉल नहीं करते हैं, तो एक्स इसे पुनरारंभ होने तक रखेगा।
  
• XPending और XNextEvent - उपस्थिति की जाँच करें और निम्नलिखित घटना प्राप्त करें:
  

  जबकि ( सुनकर ) {
  जबकि ( Lib। XPending ( प्रदर्शन ) > 0 ) {
  लिब। XNextEvent ( प्रदर्शन, घटना ) ;
  अगर ( घटना। टाइप == की- वर्ड ) {
  // यूनियन एक्सईवेंट से हमारे कार्यक्रम को पढ़ें
  // JNA को नहीं पता है कि संघ को कौन सा क्षेत्र भरना है,
  // इसलिए उसे यह बताने की जरूरत है कि किन क्षेत्रों को गिनना है।
  XKeyEvent xkey = ( XKeyEvent ) घटना। readField ( "xkey" ) ;
  
  // स्पष्ट कचरा संशोधक
  int state = xkey। स्थिति & ( ShiftMask | ControlMask | Mod1Mask | Mod4Mask )
  प्रणाली। बाहर । Println ( "Yattaaaa, hotkey with code:" + xkey। keycode + "और संशोधक:" + राज्य ) ;
  }
  }
  
  थ्रेड। नींद ( 300 ) ;
  }

  
  

मैक OSX

मैक OSX के लिए कोड का आधार ऑस्ट्रुपोर्ट-कनेक्टर के लेखक टॉर्स्टन उहल्मन का काम था:

सार्वजनिक इंटरफ़ेस कार्बन फैली लाइब्रेरी {
सार्वजनिक स्थैतिक कार्बन Lib = ( कार्बन ) मूल । loadLibrary ( "कार्बन" , कार्बन। वर्ग ) ;

सार्वजनिक स्थैतिक अंतिम int cmdKey = 0x0100 ;
सार्वजनिक स्थिर अंतिम int शिफ्ट = 0x0200 ;
सार्वजनिक स्थिर अंतिम int विकल्प ey = 0x0800 ;
सार्वजनिक स्थिर अंतिम int controlKey = 0x1000 ;

// OS_TYPE स्ट्रिंग कैरेक्टर्स को इंटेंस में बदल देता है
निजी स्थिर अंतिम int kEventClassKeyboard = OS_TYPE ( " कीब " ) ;
निजी स्थिर अंतिम इंट टाइप EventHotKeyID = OS_TYPE ( "hkid" ) ;
निजी स्थिर अंतिम int kEventParamDirectObject = OS_TYPE ( "----" ) ;

सार्वजनिक सूचक GetEventDispatcherTarget ( ) ;

public int InstallEventHandler ( Pointer inTarget, EventHandlerProcPtr inHandler, int inNumTypes, EventTypeSpec [ ] inList, Pointer inUserData, PointerByReference outRef ) ;
सार्वजनिक int RegisterEventHotKey ( int inHotKeyCode, int inHotKeyModifiers, EventHotKeyID; ByValue inHotKeyID, सूचक inTarget, int inOptions, PointerByReference outRef ) ;
सार्वजनिक int GetEventParameter ( Pointer invent, int inName, int inDesiredType, Pointer outActualType, int inBufferSize, IntBuffer outActualSize, EventHotKeyID outData ) ;
सार्वजनिक int RemoveEventHandler ( सूचक inHandlerRef ) ;
सार्वजनिक int UnregisterEventHotKey ( सूचक inHotKey ) ;

सार्वजनिक वर्ग EventTypeSpec का विस्तार
सार्वजनिक इंट इवेंटक्लास ;
सार्वजनिक int इवेंटकाइंड ;
}

सार्वजनिक स्थैतिक वर्ग EventHotKeyID संरचना का विस्तार {
सार्वजनिक इंट हस्ताक्षर ;
सार्वजनिक इंट आईडी ;

सार्वजनिक स्थिर वर्ग ByValue EventHotKeyID लागू करता है संरचना। बायवैलू {
}
}

सार्वजनिक स्थिर इंटरफ़ेस EventHandlerProcPtr का विस्तार कॉलबैक {
सार्वजनिक इंट कॉलबैक ( पॉइंटर इनहैंडलरकैलरिफ, पॉइंटर इनवेंट, पॉइंटर इनयूसेराटाटा ) ;
}
}

• GetEventDispatcherTarget - सिस्टम ईवेंट हैंडलर का लिंक प्राप्त करें
• InstallEventHandler - हमारे हैंडलर को इस ईवेंट हैंडलर में जोड़ता है। अन्य प्लेटफार्मों के विपरीत, कार्बन में घटनाएं कॉलबैक के माध्यम से अतुल्यकालिक रूप से आती हैं:
  

  EventHandlerReference = new PointerByReference ( ) ;
  // वास्तव में ही हैंडलर है
  keyListener = नया इवेंटहैंडलर ( ) ;
  
  // एक संरचना से एक सरणी बनाने के लिए जेएनए जादू
  EventTypeSpec [ ] EventTypes = ( EventTypeSpec [ ] ) ( नया EventTypeSpec ( ) । ToArray ( 1 ) ) ;
  EventTypes [को ० ] । EventClass = kEventClassKeyboard ;
  EventTypes [को ० ] । EventKind = kEventHotKeyPressed ;
  
  int status = लिब। InstallEventHandler ( Lib। GetEventDispatcherTarget ( ) , कीलिस्टनर, 1 , ईवेंटटाइप्स, अशक्त , ईवेंटहैंडलर संदर्भ ) ;

  
  यहां हम संकेत देते हैं कि हम कीबोर्ड संदेशों को संसाधित करेंगे, अर्थात् गर्म कुंजियों को दबाएंगे।
  EventHandlerReference एक हैंडलर संदर्भ बैक के साथ आता है, जिसे RemoveEventHandler में आवश्यक है।
  
  ईवेंट हैंडलर इस प्रकार है:
  

  निजी वर्ग EventHandler कार्बन को लागू करता है । EventHandlerProcPtr {
  सार्वजनिक int कॉलबैक ( सूचक inHandlerCallRef, सूचक सूचक, सूचक सूचक inserserata ) {
  EventHotKeyID eventHotKeyID = नया EventHotKeyID ( ) ;
  // इवेंट पैरामीटर प्राप्त करें
  int ret = लिब। GetEventParameter ( InEvent, kEventParamDirectObject, typeEventHotKeyID, null , eventHotKeyID। size ( ) , null , eventHotKeyID ) ;
  अगर ( रिट ! = 0 ) {
  लकड़हारा। चेतावनी ( "इवेंट पैरामीटर नहीं मिल सका। त्रुटि कोड:" + ret ) ;
  } {
  // यहां इवेंट आईडी प्राप्त करें और संसाधित करें
  int eventId = eventHotKeyID। आईडी ;
  लकड़हारा। जानकारी ( "प्राप्त ईवेंट आईडी:" + eventId ) ;
  }
  वापसी 0 ;
  }
  }

  
  
• RegisterEventHotKey - एक हॉटकी पंजीकृत करें। इनपुट कुंजी कोड है। कोड टेबल यहाँ है । निम्नलिखित संशोधक की एक सूची है। फिर EventHotKeyID.ByValue संरचना, जिसमें हमारा पहचानकर्ता और चार-अक्षर हस्ताक्षर अंकित हैं। ByValue का उपयोग किया जाता है, क्योंकि डिफ़ॉल्ट रूप से, संरचनाएं संदर्भ द्वारा पारित की जाती हैं, और हमें मूल्य द्वारा आवश्यकता होती है। इस हॉटकी में एक लिंक दिया गया है, जिसका उपयोग UnregisterEventHotKey में किया जाता है:
  
  

  EventHotKeyID। ByValue hotKeyReference = नया EventHotKeyID। बायवैलु ( ) ;
  hotKeyReference। आईडी = 1 ;
  hotKeyReference। हस्ताक्षर = OS_TYPE ( "hk01" ) ;
  PointerByReference gMyHotKeyRef = नया PointerByReference ( ) ;
  
  int status = लिब। RegisterEventHotKey ( कोड, संशोधक, hotKeyReference, Lib। GetEventDispatcherTarget ( ) , 0 , gMyHotKeyRef ) ;

  
  

निष्कर्ष

सामान्य तौर पर, सब कुछ काफी सरल होता है, हालांकि कुछ समस्याएं थीं, जैसे कि FreeBSD पर डायरेक्ट मैपिंग का उपयोग करते समय क्रैश, JNA ने XGrabKey में बूलियन को मैप करने से इंकार कर दिया, संदर्भ द्वारा संरचना को पारित करते समय अजीब त्रुटियां, और कार्बन में मूल्य के लिए नहीं, X11 द्वारा उत्पन्न त्रुटियां। यदि हॉटकी पहले से ही ली गई है, जो केवल प्रोग्राम को काट देती है, तो कार्बन पर किसी भी दस्तावेज को खोजने में कठिनाई होती है।

इस सभी कोड को LGPL 3 लाइसेंस के तहत jkeymaster लाइब्रेरी में संकलित किया गया है। इंटरफ़ेस Swing से KeyStroke पर आधारित है। विंडोज़ और X11 के लिए आप मीडिया बटन - प्ले / पॉज़, स्टॉप, नेक्स्ट ट्रैक, पिछला ट्रैक रजिस्टर कर सकते हैं।

रिमार्क्स और पैच का स्वागत है।

ps इस पोस्ट को tulskiy ने लिखा है, जो मार्गरिन की बदौलत अब हब पर है तो सभी उसे करने के लिए प्लस।