👩🏽‍🍳 🦁 ♒️ हम स्मार्टफोन के लिए खुद को रिमोट-डेस्कटॉप क्लाइंट बनाते हैं। भाग 1: सर्वर-साइड 🛷 🚀 👨🏿‍🌾

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

लेख के पहले भाग में, मैं खुद को एक साधारण रिमोट डेस्कटॉप एप्लिकेशन बनाने के लिए प्रतिबंधित करूंगा जिसमें सर्वर और क्लाइंट दोनों ही आपके डेस्कटॉप कंप्यूटर पर काम करेंगे। दूसरे और तीसरे भाग में मैं इमेज कंप्रेशन और फोन पर ही प्रोग्रामिंग करने पर विचार करूंगा।

मैं इस तरह की अंतिम कार्यक्षमता की कल्पना करता हूं: एक डेकोटॉप (सर्वर) पर, एक प्रोग्राम रेजिडेंट हैंग करता है, जो कि बाहर से आए यूडीपी पैकेट द्वारा, रिटर्न एड्रेस पर इमेज के टुकड़े ट्रांसमिट करना शुरू कर देता है। फ़ोन (क्लाइंट) पर भेजे गए टुकड़े प्रदर्शित होते हैं। उपयोगकर्ता डिस्प्ले विंडो को शिफ्ट कर सकता है या उसके अंदर क्लिक कर सकता है। यूडीपी के माध्यम से पाली और क्लिक के बारे में जानकारी उसी तरह से सर्वर पर प्रसारित की जाती है।

मैं सी # में लिखने के लिए पहले से माफी चाहता हूं, जैसे कि यह जावास्क्रिप्ट था - सबसे पहले, लेख में मैं छोटी लिस्टिंग के साथ प्राप्त करना चाहता हूं, दूसरी बात, कार्यक्रम वास्तव में सरल है और जटिल डेटा संरचनाओं को नस्ल करने का कोई कारण नहीं है। क्यों, ठीक है, और तीसरी बात, C # अब विशुद्ध रूप से OOP भाषा नहीं है।

कार्यक्रम की छोटी जटिलता के कारण, मैंने सबसे सरल "घुटने-गहरी" विकास प्रक्रिया को भी चुना जो मुझे पता है - अनुक्रमिक सरल जटिलताओं।

आइए सबसे सरल प्रोग्राम से शुरू करें जो हमें गति में हमारे डेस्कटॉप का एक टुकड़ा दिखाता है:

using System; using System.Collections.Generic; using System.Windows.Forms; using System.Drawing; namespace rd2 { class Program { static void Main(string[] args) { Form f = new Form(); var timer = new System.Windows.Forms.Timer() { Interval = 40 }; timer.Tick += (s, e) => { Graphics g = f.CreateGraphics(); g.CopyFromScreen(0, 0, 0, 0, f.Size); g.Dispose(); }; timer.Start(); Application.Run(f); } } }

यहां सब कुछ सरल है: हम एक विंडो बनाते हैं, एक टाइमर बनाते हैं, उन घटनाओं के अनुसार जहां से छवि को कैप्चर किया जाएगा और विंडो में कॉपी किया जाएगा, चलाएगा। हम सुनिश्चित करते हैं कि सब कुछ काम करे।

सब कुछ काम करता है

अब एक डेस्कटॉप ड्रैग जोड़ें और विंडो के अंदर ड्रॉप करें। फॉर्म बनाने के तुरंत बाद, डालें:

 Point window_topleft = new Point(); Size mouse_prev_loc = new Size(); bool mouse_lbdown = false; f.MouseDown += (s,e) => { mouse_lbdown = true; }; f.MouseUp += (s, e) => { mouse_lbdown = false; }; f.MouseMove += (s, e) => { if (mouse_lbdown) window_topleft += mouse_prev_loc - (Size)(e.Location); mouse_prev_loc = (Size)e.Location; };

चर window_topleft उस क्षेत्र के ऊपरी बाएं कोने का समन्वय है जो खिड़की में प्रदर्शित होता है। फिक्स कॉपीफ्रॉमस्क्रीन:

 g.CopyFromScreen(window_topleft.X, window_topleft.Y, 0, 0, f.Size);

बहुत बढ़िया! घसीटा जा रहा है।

अब हम बाईं माउस बटन के क्लिक के प्रसंस्करण को जोड़ते हैं, ताकि खिड़की के अंदर का क्लिक इस विंडो में प्रदर्शित होने वाले क्लिक पर अनुवाद हो। खींचने और क्लिक करने के बीच अंतर करने के लिए, मैं उन निर्देशांकों को याद रखूंगा जिनमें माउस बटन को क्लिक किया गया था, और यदि माउस दबाने से बहुत दूर नहीं है, तो मैं ड्रैग करने के बजाय माउस क्लिक उत्पन्न करूँगा। इस तरह:

 Point mouse_down_loc = new Point(); f.MouseDown += (s, e) => { mouse_lbdown = true; mouse_down_loc = e.Location; }; f.MouseUp += (s, e) => { mouse_lbdown = false; if( Math.Abs(e.Location.X - mouse_down_loc.X) <1 && Math.Abs(e.Location.Y - mouse_down_loc.Y) <1) { int click_to_x = (window_topleft.X + mouse_down_loc.X) * 65536 / Screen.PrimaryScreen.Bounds.Width; int click_to_y = (window_topleft.Y + mouse_down_loc.Y) * 65536 / Screen.PrimaryScreen.Bounds.Height; mouse_event((uint)(MOUSEEVENTF_LEFTDOWN | MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_MOVE), (uint)click_to_x, (uint)click_to_y, 0, 0); mouse_event((uint)(MOUSEEVENTF_LEFTUP | MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_MOVE), (uint)click_to_x, (uint)click_to_y, 0, 0); } };

WinAPI mouse_event फ़ंक्शन के लिए लगातार दो कॉल से एक माउस क्लिक प्राप्त होता है। पहला कॉल बटन प्रेस (MOUSEEVENTF_LEFTDOWN) है, दूसरा रिलीज़ (MOUSEEVENTF_LEFTUP) है। एक बटन के क्लिक के साथ, हम माउस के आंदोलन (MOUSEEVENTF_MOVE) को वांछित निर्देशांक में स्थानांतरित करते हैं, जो निरपेक्ष मान (MOUSEEVENTF_ABSOLUTE) द्वारा इंगित किए जाते हैं। शून्य निरपेक्ष माउस निर्देशांक प्राथमिक स्क्रीन (प्राइमरीस्क्रीन) के ऊपरी बाएँ कोने में स्थित हैं। बिंदु (65535, 65535) उसी स्क्रीन के निचले दाएं कोने में स्थित है। अन्य सभी स्क्रीन, यदि वे सिस्टम में हैं, इस वर्ग से सटे हैं।

ठीक है, ज़ाहिर है, आपको अपने आप को mouse_event निर्यात करना होगा। यह घोषणा वर्ग घोषणा में स्थित है:

 [DllImport("user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)] public static extern void mouse_event(uint dwFlags, uint dx, uint dy, uint cButtons, uint dwExtraInfo); private const int MOUSEEVENTF_MOVE = 0x01; private const int MOUSEEVENTF_LEFTDOWN = 0x02; private const int MOUSEEVENTF_LEFTUP = 0x04; private const int MOUSEEVENTF_ABSOLUTE = 0x8000;

आगे बढ़ने से पहले सोचने वाली बातें।

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

एक स्क्रीन के टुकड़े को स्थानांतरित करना यहां तक कि 10 हर्ट्ज की आवृत्ति के साथ एक स्मार्टफोन स्क्रीन का आकार 3 * 800 * 480 * 10 = 11520000 बाइट्स प्रति सेकंड है। यह लगभग 100 मेगाबिट्स है। आप संपीड़न के बिना नहीं कर सकते।
स्क्रीन के कुछ हिस्सों को बदलने की आवश्यकता नहीं है जो नहीं बदले हैं - कुछ काफी हो सकते हैं। लेकिन आप अपरिवर्तित भागों को फिर से भेजने से पूरी तरह से इंकार नहीं कर सकते हैं - हमारे पास एक अविश्वसनीय चैनल है, और वास्तव में, हम नहीं जानते कि ग्राहक पर क्या प्रदर्शित होता है।

विंडो का आकार भिन्न हो सकता है। उदाहरण के लिए, फोन को पोर्ट्रेट से लैंडस्केप मोड में बदलने के कारण।
हालांकि, एक बार में इन सभी टिप्पणियों को ध्यान में रखना असंभव है - काम प्रतिबिंब से उत्पन्न होगा। इसलिए, शुरुआत के लिए, सरलता की खातिर, आप जो कुछ भी कर सकते हैं, उसे अनदेखा करें।

हम दो में विभाजित हैं

और अब हम मौजूदा प्रोग्राम को दो में विभाजित करना शुरू करेंगे - सर्वर और क्लाइंट। उन्हें एक ही प्रक्रिया के भीतर रहने दें, लेकिन उन्हें अलग-अलग थ्रेड में काम करने दें और डेटा के अनुसार एक-दूसरे पर निर्भर न हों।

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

समवर्ती queue यूडीपी से संबंधित कई मायनों में है, और जब हम समवर्ती queue के माध्यम से इंटरैक्शन को डीबग करते हैं, तो मुझे उम्मीद है कि मैं काम को भेजने और डेटाग्राम प्राप्त करने के साथ कतार से बदल दूंगा। इस तरह के प्रतिस्थापन को सरल बनाने के लिए, आपको यह सुनिश्चित करने के लिए कार्यक्रम लाने की आवश्यकता है कि छोटी लंबाई के बाइट्स के अनुक्रमों को कतारों में प्रेषित किया जाए।
लेकिन पहले, मैं टाइप की गई कतारों का उपयोग करूंगा।
शेयर

सबसे पहले, हम डेटा संरचनाओं को परिभाषित करते हैं जिनका उपयोग सर्वर से क्लाइंट को संदेश भेजने और इसके विपरीत करने के लिए किया जाएगा:

 struct ImageChunk { public Rectangle place; public Bitmap img; }; struct ControlData { public enum Action : byte { Shift, Click }; public Action action; public Point point; }

इसलिए, सर्वर क्लाइंट को छवि भेजता है, यह दर्शाता है कि यह उसके सर्वर पर स्थित था, मॉनिटर। रिवर्स - शिफ्ट्स (शिफ्ट) और माउस क्लिक (क्लिक); हम हर जगह सर्वर निर्देशांक का उपयोग करने के लिए सहमत हैं।

अब मौजूदा मुख्य फ़ंक्शन को फिर से कॉपी करें, सर्वर और क्लाइंट दोनों प्रतियों का नाम बदलें, और एक नया मुख्य लिखें:

 static void Main(string[] args) { var img_channel = new BlockingCollection<ImageChunk>( new ConcurrentQueue<ImageChunk>() ); var control_channel = new BlockingCollection<ControlData>( new ConcurrentQueue<ControlData>()); Server(control_channel, img_channel); Client(img_channel, control_channel); }

एक साधारण फ्लोचार्ट के पाठ की रूपरेखा की तरह लगता है, है ना?

हम सर्वर से वह सब हटा देंगे जो स्क्रीन कैप्चर और कतारों के साथ काम करने के लिए लागू नहीं होता है। साथ ही, मैंने क्लाइंट और सर्वर पर 400x300 के आकार में विंडो का आकार ठीक करने का निर्णय लिया ताकि लिस्टिंग पैराग्राफ के एक और जोड़े को विकसित न कर सके।

 static void Server(BlockingCollection<ControlData> input, BlockingCollection<ImageChunk> output) { Point window_topleft = new Point(); Size window_size = new Size(400, 300); var timer = new System.Windows.Forms.Timer() { Interval = 40 }; timer.Tick += (s, e) => { //       ControlData incoming; while (input.TryTake(out incoming)) { switch (incoming.action) { case ControlData.Action.Click: mouse_event((uint)(MOUSEEVENTF_LEFTDOWN | MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_MOVE), (uint)incoming.point.X, (uint)incoming.point.Y, 0, 0); mouse_event((uint)(MOUSEEVENTF_LEFTUP | MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_MOVE), (uint)incoming.point.X, (uint)incoming.point.Y, 0, 0); break; case ControlData.Action.Shift: window_topleft = incoming.point; break; } } //        var b = new Bitmap(window_size.Width,window_size.Height); var g = Graphics.FromImage(b); g.CopyFromScreen(window_topleft.X, window_topleft.Y, 0, 0, window_size); g.Dispose(); output.Add(new ImageChunk() { img = b, place = new Rectangle(window_topleft, window_size) } ); }; timer.Start(); }

क्लाइंट से, हम वह सब कुछ हटा देते हैं जो सर्वर अब इसके लिए करता है:

 static void Client(BlockingCollection<ImageChunk> input, BlockingCollection<ControlData> output) { Form f = new Form(){ ClientSize = new Size(400, 300) }; Point window_topleft = new Point(); Size mouse_prev_loc = new Size(); bool mouse_lbdown = false; Point mouse_down_loc = new Point(); //    f.MouseDown += (s, e) => { mouse_lbdown = true; mouse_down_loc = e.Location; }; f.MouseUp += (s, e) => { mouse_lbdown = false; if (Math.Abs(e.Location.X - mouse_down_loc.X) < 1 && Math.Abs(e.Location.Y - mouse_down_loc.Y) < 1) { int click_to_x = (window_topleft.X + mouse_down_loc.X) * 65536 / Screen.PrimaryScreen.Bounds.Width; int click_to_y = (window_topleft.Y + mouse_down_loc.Y) * 65536 / Screen.PrimaryScreen.Bounds.Height; output.Add(new ControlData() { action=ControlData.Action.Click, point=new Point(click_to_x,click_to_y) }); } }; f.MouseMove += (s, e) => { if (mouse_lbdown) { window_topleft += mouse_prev_loc - (Size)(e.Location); output.Add(new ControlData() { action = ControlData.Action.Shift, point = window_topleft } ); } mouse_prev_loc = (Size)e.Location; }; //    var timer = new System.Windows.Forms.Timer() { Interval = 40 }; timer.Tick += (s, e) => { ImageChunk incoming; //    -  if( ! input.TryTake(out incoming,5) ) return; Graphics g = f.CreateGraphics(); g.DrawImageUnscaled(incoming.img, incoming.place.X - window_topleft.X, incoming.place.Y - window_topleft.Y); g.Dispose(); incoming.img.Dispose(); }; timer.Start(); Application.Run(f); }

एप्लिकेशन का स्वरूप नहीं बदला है, इसलिए कोई स्क्रीनशॉट नहीं होगा।

NB: वैसे, आप यहाँ कांटा कर सकते हैं ..

... और अपने आप को पाइप के माध्यम से एक दूरस्थ डेस्कटॉप बनाते हैं, http के माध्यम से, RS232 के माध्यम से, आदि बस क्रमबद्धता, संपीड़न, और वस्तुओं के लिए परिवहन लिखें जो कि कतारों में हैं।

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

हम स्मार्टफोन के लिए खुद को रिमोट-डेस्कटॉप क्लाइंट बनाते हैं। भाग 1: सर्वर-साइड

आगे बढ़ने से पहले सोचने वाली बातें।

हम दो में विभाजित हैं

NB: वैसे, आप यहाँ कांटा कर सकते हैं ..

More articles: