हम आपके Android एप्लिकेशन में Twitter को एकीकृत करते हैं

हम आपके Android एप्लिकेशन में Twitter को एकीकृत करते हैं

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

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

हम शुरू करते हैं

और इसलिए हमें एक काम करने वाले ट्विटर खाते की आवश्यकता है (यदि आपके पास एक नहीं है, तो यहां पंजीकरण करें )। इसके बाद, हमें ट्विटर के साथ बातचीत करने के लिए अपना परीक्षण आवेदन पंजीकृत करना होगा। और इसलिए यहां हम जाते हैं
अब हम आवश्यक फ़ील्ड भरते हैं, हमारे लिए केवल निम्न, एप्लिकेशन प्रकार (एप्लिकेशन प्रकार) - ब्राउज़र, डिफ़ॉल्ट एक्सेस प्रकार - पढ़ना और लिखना महत्वपूर्ण है। शेष को मनमाने ढंग से भर दिया जाता है, लेकिन इनपुट डेटा के प्रारूप को याद करते हुए (हम कुछ ऐसा दर्ज करने का प्रयास नहीं कर रहे हैं जैसे & # ^ & JKLLKL: URL और कॉलबैक URL में, वह सब कुछ दर्ज करें जैसा उसे चाहिए)।

जैसे ही हम सभी क्षेत्रों में भर गए, कैप्चा में प्रवेश किया - हम निम्नलिखित पाठ देखेंगे।

उपभोक्ता कुंजी
************************* (चरित्र सेट)
उपभोक्ता रहस्य
************************* (चरित्र सेट)
टोकन URL का अनुरोध करें
api.twitter.com/oauth/request_token
टोकन URL तक पहुँचें
api.twitter.com/oauth/access_token
URL अधिकृत करें
api.twitter.com/oauth/authorize
पंजीकृत OAuth कॉलबैक URL
smth.com

हां, हम अपने एप्लिकेशन में इस कॉलबैक का उपयोग नहीं करेंगे, वहां हम थोड़ा अलग कार्य करेंगे और अपने कॉलबैक को परिभाषित करेंगे।

एक आवेदन लिखना शुरू करें

और इसलिए हमें निम्नलिखित पुस्तकालयों की आवश्यकता है:

• पताका का स्तंभ-commonshttp4-1.2.1.1.jar
• पताका का स्तंभ कोर-1.2.1.1.jar
• httpclient-4.0.1.jar
• twitter4j कोर-2.1.11

और इसलिए अब हमारे पास एसीसी है। पुस्तकालय।
नतीजतन, हम एक छोटी योजना की रूपरेखा तैयार करते हैं कि हमारा आवेदन कैसा दिखेगा। सादगी के लिए, केवल 1 गतिविधि होगी।

• स्थिति पट्टी जो प्रदर्शित करती है कि हम ट्विटर से जुड़े हैं या नहीं
• ट्वीट बटन, जो वास्तव में हमारे परीक्षण संदेश को पोस्ट करता है, और अगर हम लॉग इन नहीं हैं, तो यह एक ब्राउज़र खोलता है जिसमें हम लॉग इन करते हैं
• पिछली सेटिंग्स को साफ़ करते हुए (यदि कोई अन्य एप्लिकेशन खाता का उपयोग करता है)

लगातार फ़ाइल

इस फ़ाइल में हम कनेक्शन के लिए आवश्यक स्थिरांक परिभाषित करते हैं।

public class Constants { public static final String CONSUMER_KEY = "<  CONSUMER KEY >"; public static final String CONSUMER_SECRET= "< CONSUMER SECRET >"; public static final String REQUEST_URL = "http://api.twitter.com/oauth/request_token"; public static final String ACCESS_URL = "http://api.twitter.com/oauth/access_token"; public static final String AUTHORIZE_URL = "http://api.twitter.com/oauth/authorize"; final public static String CALLBACK_SCHEME = "x-latify-oauth-twitter"; final public static String CALLBACK_URL = CALLBACK_SCHEME + "://callback"; } 

मुझे आपको ट्विटर और एप्लिकेशन के बीच की बातचीत का आरेख दें।


CONSUMER_KEY - हमारे आवेदन के लिए एक अनोखी कुंजी, जैसे ही हमारा आवेदन पंजीकृत होता है, हमें प्राप्त होता है (लॉगिन जैसा कुछ)
CONSUMER_SECRET - हमारे आवेदन के लिए एक गुप्त कुंजी ("लॉगिन" के लिए पासवर्ड की तरह कुछ)
REQUEST_URL - अनुरोध टोकन प्राप्त करने की आवश्यकता है। औथ का हिस्सा। हम पंजीकरण के तुरंत बाद प्राप्त करते हैं।
AUTHORIZE_URL - ट्विटर तक पहुँचने के लिए आवश्यक URL। औथ का हिस्सा। हम पंजीकरण के तुरंत बाद प्राप्त करते हैं।
ACCESS_URL - एक्सेस टोकन प्राप्त करने के लिए। औट का हिस्सा। हम पंजीकरण के तुरंत बाद प्राप्त करते हैं।
कॉलबैक स्कीम एक विशिष्ट पहचानकर्ता है जिसे हम एक्सेस टोकन प्राप्त करने के लिए कॉलबैक के रूप में उपयोग करते हैं। सामान्यतया, सर्किटरी का विकल्प कुछ भी सीमित नहीं है। उदाहरण के लिए, हम यहां x-sample-oauth-twitter का उपयोग करेंगे।
CALLBACK_URL - वास्तव में हमारा कॉलबैक जिसके साथ हमें एक उत्तर मिला कि प्राधिकरण सफल रहा है, हम उन अनुरोधों को भेज सकते हैं जिनकी हमें एक्सेस टोकन का उपयोग करने की आवश्यकता है।

कलरव बटन

 tweet.setOnClickListener(new View.OnClickListener() { public void onClick(View v) { if (TwitterUtils.isAuthenticated(prefs)) { sendTweet(); } else { Intent i = new Intent(getApplicationContext(), PrepareRequestTokenActivity.class); i.putExtra("tweet_msg",getTweetMsg()); startActivity(i); } } }); 

यहां सब कुछ सरल है, हमारा बटन बस यह जांचता है कि क्या उपयोगकर्ता लॉग इन है, यदि सब कुछ ठीक है, तो हम अपना संदेश भेजते हैं, यदि नहीं, तो यह हमें ब्राउज़र में लॉग इन करने की पेशकश करता है। ऐसा करने के लिए, UseRequestTokenActivity का उपयोग करें। बाद में लॉग इन प्रक्रिया।

Autenfikatsiya

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

ReadyRequestTokenActivity - उपयोगकर्ता और प्रदाता OAuth (Signpost लाइब्रेरी) को सेट करता है और एसिंक्रोनस OAuthRequestTokenTask शुरू करता है। इसमें एक कॉलबैक भी शामिल है जब हम एक्सेस टोकन प्राप्त करने के लिए पहले से ही प्रमाणित हैं।
OAuthRequestTokenTask - अनुरोध टोकन प्राप्त करने और ब्राउज़र को कॉल करने के लिए जिम्मेदार है, जिसमें हम वास्तव में प्रमाणीकरण के माध्यम से करते हैं।
RetrieveAccessTokenTask - आंतरिक वर्ग। तैयार की गई NewRntestTokenActivity की नई विधि पर कहा जाता है। प्राधिकरण के बाद हमारे प्राप्त टोकन संग्रहीत करता है।

ReadyRequestTokenActivity और अतुल्यकालिक OAuthRequestTokenTask कॉल

 @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); try { this.consumer = new CommonsHttpOAuthConsumer(Constants.CONSUMER_KEY, Constants.CONSUMER_SECRET); this.provider = new CommonsHttpOAuthProvider(Constants.REQUEST_URL,Constants.ACCESS_URL,Constants.AUTHORIZE_URL); } catch (Exception e) { Log.e(TAG, "Error creating consumer / provider",e); } Log.i(TAG, "Starting task to retrieve request token."); new OAuthRequestTokenTask(this,consumer,provider).execute(); } 

यहां हमें एप्लिकेशन पर नियंत्रण वापस करने के लिए हमारा कॉलबैक URL मिलता है (x-oauthflow-twitter: // callback)।

 @Override protected Void doInBackground(Void... params) { try { Log.i(TAG, "Retrieving request token from Google servers"); final String url = provider.retrieveRequestToken(consumer, Constants.OAUTH_CALLBACK_URL); Log.i(TAG, "Popping a browser with the authorize URL : " + url); Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse(url)).setFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP | Intent.FLAG_ACTIVITY_NO_HISTORY | Intent.FLAG_FROM_BACKGROUND); context.startActivity(intent); } catch (Exception e) { Log.e(TAG, "Error during OAUth retrieve request token", e); } return null; } 

लॉगिन पेज

और इसलिए हम लॉगिन पेज पर हैं।
ब्राउजर को शुरू करने के लिए, हमारी गतिविधि (प्रिप्ररेक्टटेक्टेनएक्टिविटी) को मैनिफ़ेस्ट फ़ाइल (AndroidManifest.xml) में पंजीकृत करें।
<activity android:name=".PrepareRequestTokenActivity" android:launchMode="singleTask">>
<intent-filter>
<action android:name="android.intent.action.VIEW" />
<category android:name="android.intent.category.DEFAULT" />
<category android:name="android.intent.category.BROWSABLE" />
<data android:scheme="x-oauthflow-twitter" android:host="callback" />
</intent-filter>



हम काम करना जारी रखते हैं। अब हमें अपने माइक्रोब्लॉग को एक्सेस करने के लिए एक एक्सेस टोकन प्राप्त करने की आवश्यकता है, हम यह रिट्रीवेएटाकाउटनटैस्क के माध्यम से करते हैं। OnNewIntent विधि द्वारा पहले से ही ऊपर वर्णित है।

 @Override public void onNewIntent(Intent intent) { super.onNewIntent(intent); SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this); final Uri uri = intent.getData(); if (uri != null && uri.getScheme().equals(Constants.OAUTH_CALLBACK_SCHEME)) { Log.i(TAG, "Callback received : " + uri); Log.i(TAG, "Retrieving Access Token"); new RetrieveAccessTokenTask(this,consumer,provider,prefs).execute(uri); finish(); } } 

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

 @Override protected Void doInBackground(Uri...params) { final Uri uri = params[0]; final String oauth_verifier = uri.getQueryParameter(OAuth.OAUTH_VERIFIER); try { provider.retrieveAccessToken(consumer, oauth_verifier); final Editor edit = prefs.edit(); edit.putString(OAuth.OAUTH_TOKEN, consumer.getToken()); edit.putString(OAuth.OAUTH_TOKEN_SECRET, consumer.getTokenSecret()); edit.commit(); String token = prefs.getString(OAuth.OAUTH_TOKEN, ""); String secret = prefs.getString(OAuth.OAUTH_TOKEN_SECRET, ""); consumer.setTokenWithSecret(token, secret); context.startActivity(new Intent(context,AndroidTwitterSample.class)); executeAfterAccessTokenRetrieval(); Log.i(TAG, "OAuth - Access Token Retrieved"); } catch (Exception e) { Log.e(TAG, "OAuth - Access Token Retrieval Error", e); } return null; } 

निष्‍कर्ष के बाद निष्‍क्रिय किए गए TokenRetrieval विधि सीधे हमारे संदेश को निकालती है और इसे OAuth का उपयोग करके प्रमाणीकरण प्रक्रिया से गुजरती है।

 private void executeAfterAccessTokenRetrieval() { String msg = getIntent().getExtras().getString("tweet_msg"); try { TwitterUtils.sendTweet(prefs, msg); } catch (Exception e) { Log.e(TAG, "OAuth - Error sending to Twitter", e); } } 

खैर, हमारे कार्य के सफल समापन के बारे में उपयोगकर्ता को सूचित करना न भूलें। इसके लिए एक साधारण टोस्ट लिखें।

 private final Handler mTwitterHandler = new Handler(); final Runnable mUpdateTwitterNotification = new Runnable() { public void run() { Toast.makeText(getBaseContext(), "Tweet sent !", Toast.LENGTH_LONG).show(); } }; 

संदेश स्वयं Twitter4J लाइब्रेरी विधियों का उपयोग करके भेजा गया है।

 public static void sendTweet(SharedPreferences prefs,String msg) throws Exception { String token = prefs.getString(OAuth.OAUTH_TOKEN, ""); String secret = prefs.getString(OAuth.OAUTH_TOKEN_SECRET, ""); AccessToken a = new AccessToken(token,secret); Twitter twitter = new TwitterFactory().getInstance(); twitter.setOAuthConsumer(Constants.CONSUMER_KEY, Constants.CONSUMER_SECRET); twitter.setOAuthAccessToken(a); twitter.updateStatus(msg); } 

यहाँ है कि मैं क्या परिणाम के रूप में है:


अनुवाद ट्यूटोरियल:
blog.doityourselfandroid.com/2011/02/13/guide-to-integrating-twitter-android-application
आगे के प्रदर्शन की जाँच के साथ।
यह इस्तेमाल किया गया था:

• साइनपोस्ट लाइब्रेरी
• Twitter4J पुस्तकालय

अंग्रेजी भाषा के लेख के लेखक के स्रोत कोड के साथ-साथ, मुझे उम्मीद है कि वे वर्णित प्रक्रिया को पूरी तरह से समझने में मदद करेंगे - लिंक लिंक