जावा: जांच रहा है कि पीसी निष्क्रिय है

Question

यह एक कठिन सवाल है क्योंकि मुझे ऑनलाइन कोई जानकारी नहीं मिली है। असल में, मैं जानना चाहता हूं कि जावा में कोई कंप्यूटर निष्क्रिय है या नहीं। मैं चाहता हूं कि कोई प्रोग्राम केवल तभी काम करे जब कंप्यूटर सक्रिय उपयोग में है लेकिन यदि यह निष्क्रिय है तो नहीं।

ऐसा करने का एकमात्र तरीका मैं माउस/कीबोर्ड में एक टाइमर रखना चाहता हूं।

एमएसएन मैसेंजर में "दूर" सुविधा है, मैं इसके समान कुछ चाहता हूं।

Answer 1

मंच-स्वतंत्र जेआरई में कुछ भी इस सवाल का जवाब नहीं देगा। आप गणना के लिए घड़ी के समय को मापकर अनुमान लगा सकते हैं, लेकिन यह विश्वसनीय नहीं होगा। विशिष्ट प्लेटफ़ॉर्म पर, विक्रेता API हो सकते हैं जो आपकी मदद कर सकते हैं।

Answer 2

जावा के पास आपके एप्लिकेशन के बाहर सिस्टम स्तर पर कीबोर्ड या माउस से बातचीत करने का कोई तरीका नहीं है।

That being said here are several ways to do it in Windows। सबसे आसान शायद JNI की स्थापना की और कीबोर्ड और माउस गतिविधि के लिए

GetLastInputInfo

मतदान पर है।

Answer 3

1) एक नया धागा बनाएं।

2) यह एक सुपर सुपर कम प्राथमिकता (दें सबसे कम आप कर सकते हैं)

3) हर दूसरे या दो, धागा कुछ सरल कार्य करने के लिए है। यदि सुपर फास्ट, कम से कम 1 सीपीयू पूरी तरह से निष्क्रिय है। यदि यह धीमा करता है, तो कम से कम 1 कोर पूरी तरह से निष्क्रिय नहीं है।

या

बस अपने कार्यक्रम को कम प्राथमिकता पर चलाएं। इससे ओएस को आपके प्रोग्राम पर अन्य प्रोग्राम चलाने के साथ सौदा करने दिया जाएगा।

Answer 4

इम एक पेशेवर नहीं है, लेकिन मैं एक विचार है:

आप माउस स्थिति की जांच करने जावा के माउस की जानकारी वर्ग का उपयोग कर सकते पर certian अंतराल कहना तरह:

import java.awt.MouseInfo; 

public class Mouse { 
    public static void main(String[] args) throws InterruptedException{ 
     while(true){ 
      Thread.sleep(100); 
      System.out.println("("+MouseInfo.getPointerInfo().getLocation().x+", "+MouseInfo.getPointerInfo().getLocation().y+")"); 
     } 
    } 
} 

साथ प्रिंट बयान बदलने के अपने तर्क, अगर कुछ अंतराल के लिए कहते हैं कि 1 मिनट माउस के पिछले स्थिति नई स्थिति के समान ही है जैसे (आप बस केवल एक्स निर्देशांक तुलना कर सकते हैं), इसका मतलब है कि प्रणाली बेकार है, और आप अपने कार्रवाई के साथ आगे के रूप में आप चाहते हैं कर सकते हैं (उम्मीद है कि यह एक कानूनी गतिविधि है जिसे आप कार्यान्वित करना चाहते हैं :-)

इसे एक नए धागे में लागू करने के लिए सुनिश्चित करें, अन्यथा आपका मुख्य कार्यक्रम निष्क्रिय राज्य की जांच के लिए लटका होगा।

Answer 5

आप जावा के रोबोट वर्ग की मदद से इस का समाधान कर सकते हैं।

, स्क्रीनशॉट लेने के लिए रोबोट वर्ग का उपयोग करें तो देता है के लिए 60 सेकंड का कहना है कि और एक अन्य स्क्रीनशॉट लेने के लिए प्रतीक्षा करें। एक दूसरे के साथ स्क्रीनशॉट तुलना करें देखने के लिए कि किसी भी परिवर्तन हुआ है, लेकिन सिर्फ पिक्सेल द्वारा स्क्रीनशॉट पिक्सेल तुलना नहीं है। बदल गए पिक्सल के प्रतिशत की जांच करें। कारण यह है कि आपके पास Windows घड़ी की तरह छोटे मतभेद परिणाम के साथ हस्तक्षेप नहीं करना चाहती है। यदि प्रतिशत 0.005% (या जो भी हो) कम है, तो कंप्यूटर शायद निष्क्रिय है।

import java.awt.AWTException; 
import java.awt.DisplayMode; 
import java.awt.GraphicsDevice; 
import java.awt.GraphicsEnvironment; 
import java.awt.Rectangle; 
import java.awt.Robot; 
import java.awt.Toolkit; 
import java.awt.image.BufferedImage; 

public class CheckIdle extends Thread { 
    private Robot robot; 
    private double threshHold = 0.05; 
    private int activeTime; 
    private int idleTime; 
    private boolean idle; 
    private Rectangle screenDimenstions; 

    public CheckIdle(int activeTime, int idleTime) { 
     this.activeTime = activeTime; 
     this.idleTime = idleTime; 

     // Get the screen dimensions 
     // MultiMonitor support. 
     int screenWidth = 0; 
     int screenHeight = 0; 

     GraphicsEnvironment graphicsEnv = GraphicsEnvironment 
       .getLocalGraphicsEnvironment(); 
     GraphicsDevice[] graphicsDevices = graphicsEnv.getScreenDevices(); 

     for (GraphicsDevice screens : graphicsDevices) { 
      DisplayMode mode = screens.getDisplayMode(); 
      screenWidth += mode.getWidth(); 

      if (mode.getHeight() > screenHeight) { 
       screenHeight = mode.getHeight(); 
      } 
     } 

     screenDimenstions = new Rectangle(0, 0, screenWidth, screenHeight); 

     // setup the robot. 
     robot = null; 
     try { 
      robot = new Robot(); 
     } catch (AWTException e1) { 
      e1.printStackTrace(); 
     } 

     idle = false; 
    } 

    public void run() { 
     while (true) { 
      BufferedImage screenShot = robot 
        .createScreenCapture(screenDimenstions); 

      try { 
       Thread.sleep(idle ? idleTime : activeTime); 
      } catch (InterruptedException e) { 
       e.printStackTrace(); 
      } 

      BufferedImage screenShot2 = robot 
        .createScreenCapture(screenDimenstions); 

      if (compareScreens(screenShot, screenShot2) < threshHold) { 
       idle = true; 
       System.out.println("idle"); 
      } else { 
       idle = false; 
       System.out.println("active"); 
      } 
     } 
    } 

    private double compareScreens(BufferedImage screen1, BufferedImage screen2) { 
     int counter = 0; 
     boolean changed = false; 

     // Count the amount of change. 
     for (int i = 0; i < screen1.getWidth() && !changed; i++) { 
      for (int j = 0; j < screen1.getHeight(); j++) { 
       if (screen1.getRGB(i, j) != screen2.getRGB(i, j)) { 
        counter++; 
       } 
      } 
     } 

     return (double) counter 
       /(double) (screen1.getHeight() * screen1.getWidth()) * 100; 
    } 

    public static void main(String[] args) { 
     CheckIdle idleChecker = new CheckIdle(20000, 1000); 
     idleChecker.run(); 
    } 
}