🎽 🧑🏿‍🤝‍🧑🏾 🏇🏼 Android के लिए लंबा मतदान 🌕 🚗 🥤

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

Js लाइब्रेरी में पूरी तरह से एनालॉग लिखने का कोई काम नहीं था, इसलिए मैंने एक विशेष, लेकिन सबसे लोकप्रिय, केस के लिए एक मॉड्यूल लिखना शुरू किया।

सर्वर साइड

तो, मैं सर्वर से शुरू करूँगा।

nginx

प्रयुक्त नेग्नेक्स-पुश-स्ट्रीम-मॉड्यूल

नगीनक्स सेटिंग्स में:

#     location /channels-stats { push_stream_channels_statistics; push_stream_channels_path $arg_id; } #     location /pub { push_stream_publisher admin; push_stream_channels_path $arg_id; push_stream_store_messages on; #   ,   ,      } #     location ~ ^/lp/(.*) { push_stream_subscriber long-polling; push_stream_channels_path $1; push_stream_message_template "{\"id\":~id~,\"channel\":\"~channel~\",\"tag\":\"~tag~\",\"time\":\"~time~\",\"text\":~text~}"; push_stream_longpolling_connection_ttl 30s; }

विन्यास में तीन निर्देशों का वर्णन किया गया है: संदेश भेजने, प्राप्त करने और आँकड़े प्राप्त करने के लिए भी।

पीएचपी

संदेश सर्वर द्वारा प्रकाशित किए जाते हैं। यहाँ php में एक उदाहरण समारोह है:

  /* * $cids - ID ,  ,     - ID  * $text - ,    */ public static function push($cids, $text) { $text = json_encode($text); $c = curl_init(); $url = 'http://example.com/pub?id='; curl_setopt($c, CURLOPT_RETURNTRANSFER, true); curl_setopt($c, CURLOPT_POST, true); $results = array(); if (!is_array($cids)) { $cids = array($cids); } $cids = array_unique($cids); foreach ($cids as $v) { curl_setopt($c, CURLOPT_URL, $url . $v); curl_setopt($c, CURLOPT_POSTFIELDS, $text); $results[] = curl_exec($c); } curl_close($c); }

यहां, सब कुछ सरल है: हम चैनल (संदेश) और संदेश भेजना चाहते हैं जो हम भेजते हैं। इस तथ्य के कारण कि सादा सादे पाठ किसी के लिए दिलचस्प नहीं है, और एक अद्भुत जोंस प्रारूप है, आप वस्तुओं को तुरंत भेज सकते हैं।

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

परिणामस्वरूप, तीन मापदंडों से मिलकर निम्नलिखित प्रारूप विकसित किया गया:

 [id ]_[ ]_[id ]

यदि हम सभी उपयोगकर्ताओं को संदेश भेजना चाहते हैं, तो हम चैनल का उपयोग करते हैं:

 0_main_0

अगर यूजर आईडी = 777:

 777_main_0

यदि सभी के लिए सूची मूल्य क्रमांक 7 = आईडी के साथ बदल गया है, तो:

 0_orderPriceChanged_777

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

 const ACT_NEW_MESSAGE = 1; LongPolling::push($uid."_main_0", array( "act" => ACT_NEW_MESSAGE, "content" => "Hello, user ".$uid."!", ));

ग्राहक भाग

सर्वर साइड के बारे में सब कुछ लगता है। चलो जावा के लिए नीचे उतरो!
जिस कक्षा को मैंने गिहब पर पोस्ट किया था ।
अपने पुस्तकालय में, मैंने एंड्रॉइड-एसयूएनसी-http लाइब्रेरी का उपयोग किया, जो सुविधाजनक एसिंक्रोनस http अनुरोध प्रदान करता है। उदाहरण में, मैंने एक संकलित जार फ़ाइल जोड़ी।

कक्षा का इंटरफ़ेस काफी सरल है।
पहले आपको कॉलबैक ऑब्जेक्ट बनाने की आवश्यकता है, जिसके तरीकों से उत्तर प्राप्त होंगे। चूंकि हम मुख्य रूप से संदेशों में वस्तुओं का उपयोग करते हैं, इसलिए हमने JsonHttpResponseHandler को कक्षा के कॉलबैक के रूप में चुना:

 private final static int ACT_NEW_ORDER = 1; private final static int ACT_DEL_ORDER = 2; private final static int ACT_ATTRIBUTES_CHANGED = 3; private final static int ACT_MESSAGE = 4; private final JsonHttpResponseHandler handler = new JsonHttpResponseHandler() { @Override public void onSuccess(int statusCode, Header[] headers, JSONObject response) { try { JSONObject json = response.getJSONObject("text"); switch (json.getInt("act")) { case ACT_NEW_ORDER: ... break; case ACT_DEL_ORDER: ... break; case ACT_ATTRIBUTES_CHANGED: ... break; case ACT_MESSAGE: ... break; default: break; } } catch (JSONException e) { e.printStackTrace(); } } };

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

इसके बाद, लॉन्गपॉलिंग ऑब्जेक्ट को इनिशियलाइज़ करें (मान लें कि हम एक्टिविटी में ऐसा करते हैं):

 private LongPolling lp; private int uid = 1; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_balance); lp = new LongPolling(getApplicationContext(), "http://example.com/lp/", Integer.toString(uid) + "_main_0", handler); }

अगर हमें गतिविधि में केवल लंबे मतदान की आवश्यकता है, तो हमें पंजीकरण करने की आवश्यकता है:

 public void onResume() { super.onResume(); lp.connect(); } public void onPause() { super.onPause(); lp.disconnect(); }

यदि आपको पूरे आवेदन में संदेश प्राप्त करने की आवश्यकता है (और यह आमतौर पर मामला है), तो ऑब्जेक्ट को एप्लिकेशन क्लास (एप्लिकेशन) या सेवा (सेवा) में आरंभीकृत किया जा सकता है।
फिर आरंभीकरण के ठीक बाद आपको सुनना शुरू करना होगा

 lp = new LongPolling(getApplicationContext(), "http://example.com/lp/", Integer.toString(uid) + "_main_0", handler); lp.connect();

और, उपयोगकर्ता की बैटरी को न गिराने के लिए, आपको इंटरनेट कनेक्शन की उपस्थिति / गायब होने की घटनाओं के लिए ब्रॉडकास्टरेवर को पंजीकृत करना होगा:
AndroidManifest.xml

 <?xml version="1.0" encoding="utf-8"?> <manifest xmlns:android="http://schemas.android.com/apk/res/android"> <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" /> <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" /> ... <application> ... <receiver android:name="com.app.example.receivers.InternetStateReceiver" > <intent-filter> <action android:name="android.net.conn.CONNECTIVITY_CHANGE" /> <action android:name="android.net.wifi.supplicant.CONNECTION_CHANGE" /> </intent-filter> </receiver> </application> </manifest>

और InternetStateReceiver

 public class InternetStateReceiver extends BroadcastReceiver { public void onReceive(Context context, Intent intent) { final ConnectivityManager connMgr = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE); final android.net.NetworkInfo wifi = connMgr.getNetworkInfo(ConnectivityManager.TYPE_WIFI); final android.net.NetworkInfo mobile = connMgr.getNetworkInfo(ConnectivityManager.TYPE_MOBILE); if (wifi != null && wifi.isAvailable() || mobile != null && mobile.isAvailable()) { application.getInstance().lp.connect(); } else { application.getInstance().lp.disconnect(); } } }

आंकड़े

ठीक है, एक रोटी के रूप में, वास्तविक समय के आँकड़े देखना दिलचस्प होगा, क्योंकि हम इसे समय में समझ लेते हैं।
मान लें कि हम ऑनलाइन उपयोगकर्ताओं की संख्या में रुचि रखते हैं।
ऐसा करने के लिए, हमें url पर XML / json जानकारी मिलती है:

 http://example.com/channels-stats?id=ALL

और निम्नलिखित देखें:

 <?xml version="1.0" encoding="UTF-8" ?> <root> <hostname>example.com</hostname> <time>2014-03-22T00:03:37</time> <channels>2</channels> <wildcard_channels>0</wildcard_channels> <uptime>818530</uptime> <infos> <channel> <name>4_main_0</name> <published_messages>0</published_messages> <stored_messages>0</stored_messages> <subscribers>1</subscribers> </channel> <channel> <name>23_main_0</name> <published_messages>0</published_messages> <stored_messages>0</stored_messages> <subscribers>1</subscribers> </channel> </infos> </root>

सब्सक्राइबर टैग में, हम प्रत्येक चैनल के श्रोताओं की संख्या देखते हैं। लेकिन इस मामले में चूंकि प्रत्येक उपयोगकर्ता का अपना चैनल है, PHP में हम ऑनलाइन उपयोगकर्ताओं की सूची संकलित करेंगे:

 const STATISTICS_URL = 'http://example.com/channels-stats?id=ALL'; public static function getOnlineIds() { $str = file_get_contents(self::STATISTICS_URL); if (!$str) return; $json = json_decode($str); if (empty($json -> infos)) return; $ids = array(); foreach ($json->infos as $v) { if ($v -> subscribers > 0 && substr_count($v -> channel, '_main_0') > 0) { $ids[] = str_replace('_main_0', '', $v -> channel); } } return $ids; }

तो हमें नेटवर्क पर यूजर आई.डी. लेकिन एक BUT है। फिलहाल जब क्लाइंट सर्वर से जुड़ता है, तो यह आंकड़ों में नहीं होगा, इसे ध्यान में रखा जाना चाहिए।

निष्कर्ष

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

आलोचना और सुझाव सुनकर मुझे खुशी होगी।

संदर्भ

https://github.com/jonasasx/LongPolling - वास्तव में काम का परिणाम है
https://github.com/wandenberg/nginx-push-stream-module - nxing मॉड्यूल
https://github.com/loopj/android-async-http - Android के लिए अतुल्यकालिक http अनुरोधों का पुस्तकालय

Android के लिए लंबा मतदान