在Android中 - 如何直接张贴鸣叫继Android的用户验证用户无需打开推对话框（消息对话框） [英] In Android -How directly post tweet to following users of a authenticate user in android without open Tweet dialog (Message Dialog box)
本文介绍了在Android中 - 如何直接张贴鸣叫继Android的用户验证用户无需打开推对话框（消息对话框）的处理方法，对大家解决问题具有一定的参考价值，需要的朋友们下面随着小编来一起学习吧！
问题描述
我要发布的tweet到验证user.For之后验证用户使用的微博-4J库。我已经拿到名单（名称和ID）以下的用户，但无法发布的tweet没有开放的dialog.I正在使用<一个href="http://www.mokasocial.com/2011/07/writing-an-android-twitter-client-with-image-upload-using-twitter4j/"相对=nofollow>这个链接验证
问卷如何直接张贴鸣叫下一个验证用户的用户在Android中wihout打开推对话框（消息对话框）
1。在twitterButton点击一个新的活动具有的WebView打开
twitterButton =（按钮）findViewById（R.id.twitter）;
twitterButton.setOnClickListener（新OnClickListener（）{
@覆盖
公共无效的onClick（视图v）{
// TODO自动生成方法存根
mTwitter =新TwitterFactory（）的getInstance（）。
mRequestToken = NULL;
mTwitter.setOAuthConsumer（TwitterConstants.CONSUMER_KEY，
TwitterConstants.CONSUMER_SECRET）;
字符串callbackURL = getResources（）的getString（
R.string.twitter_callback）;
尝试 {
mRequestToken = mTwitter.getOAuthRequestToken（callbackURL）;
的System.out.println（URL
+ mRequestToken.getAuthenticationURL（））;
}赶上（TwitterException E）{
e.printStackTrace（）;
}
意图I =新的意图（MMSExampleActivity.this，
TwitterScreen.class）;
i.putExtra（URL，mRequestToken.getAuthenticationURL（））;
的System.out.println（URL ====
+ mRequestToken.getAuthenticationURL（））;
startActivityForResult（ⅰ，TWITTER_AUTH）;
}
}）;
2。在onActivityResult（INT申请code，INT结果code，意图数据）的方法
如果（结果code == Activity.RESULT_OK）{
字符串oauthVerifier =（字符串）data.getExtras（）。得到（
oauth_verifier）;
AccessToken在=无效;
尝试 {
//对我们的的响应请求
在= mTwitter.getOAuthAccessToken（mRequestToken，
oauthVerifier）;
accessToken = at.getToken（）;
的System.out.println（访问令牌+ accessToken）;
accessTokenSecret = at.getTokenSecret（）;
getFollowers（）;
意图twitterFriendIntent =新的意图（MMSExampleActivity.this，TwitterFriends.class）;
twitterFriendIntent.putExtra（twitterfriends，twitterFriends）;
startActivity（twitterFriendIntent）;
}赶上（TwitterException E）{
的System.out.println（E ........）;
e.printStackTrace（）;
}
}
3。获得以下会员列表
公共无效getFollowers（）
{
ConfigurationBuilder建设者=新ConfigurationBuilder（）;
builder.setOAuthConsumerKey（TwitterConstants.CONSUMER_KEY）;
builder.setOAuthConsumerSecret（TwitterConstants.CONSUMER_SECRET）;
builder.setOAuthAccessToken（accessToken）;
builder.setOAuthAccessTokenSecret（accessTokenSecret）;
配置CONF = builder.build（）;
微博=新TwitterFactory（CONF）.getInstance（）;
尝试 {
长lCursor = -1;
标识friendsIDs = twitter.getFriendsIDs（twitter.getId（），lCursor）;
标识followersIds = twitter.getFollowersIDs（twitter.getId（），lCursor）;
的System.out.println（twitter.showUser（twitter.getId（））的getName（））;
的System.out.println（==========================）;
做
{
为（长我：friendsIDs.getIDs（））
{
好友列表friendListObj =新的好友列表（）;
friendListObj.setTwitterId（ⅰ）;
friendListObj.setTwitterUsername（twitter.showUser（ⅰ）.getName（））;
friendListObj.setTwitterUrl（twitter.showUser（ⅰ）.getScreenName（））;
twitterFriends.add（friendListObj）;
的System.out.println（跟随ID＃+ I）;
的System.out.println（twitter.showUser（ⅰ）.getName（））;
的System.out.println（twitter.showUser（ⅰ）.getProfileImageURL（））;
的System.out.println（twitter.showUser（ⅰ）.getURL（））;
}
}而（friendsIDs.hasNext（））;
}赶上（IllegalStateException异常E）{
// TODO自动生成的catch块
e.printStackTrace（）;
}赶上（TwitterException E）{
// TODO自动生成的catch块
e.printStackTrace（）;
}
}
4。 $ C $下后鸣叫
公共无效updateStatus（字符串messageToPost）{
ConfigurationBuilder建设者=新ConfigurationBuilder（）;
builder.setOAuthConsumerKey（TwitterConstants.CONSUMER_KEY）;
builder.setOAuthConsumerSecret（TwitterConstants.CONSUMER_SECRET）;
builder.setOAuthAccessToken（accessToken）;
builder.setOAuthAccessTokenSecret（accessTokenSecret）;
配置CONF = builder.build（）;
叽叽喳喳叽叽喳喳=新TwitterFactory（CONF）.getInstance（）;
的System.out.println（中更新状态）;
尝试 {
// twitter.updateStatus（的Hello World！）;
StatusUpdate状态=新StatusUpdate（messageToPost）;
的System.out.println（消息的长度是= = =
+ messageToPost.trim（）长度（））。
的System.out.println（应用程序+文件）;
status.setMedia（文件）;
的System.out.println（应用程序+ file.exists（））;
twitter.updateStatus（状态）;
的System.out.println（应用程序+文件）;
}赶上（TwitterException E）{
通信System.err.println（在更新状态时发生错误！）;
e.printStackTrace（）;
}
}
解决方案
u必须有Twitter好友的ID ......现在得到朋友们详细介绍（基本上网名）
公共类FindFriendList扩展的AsyncTask＆LT;整型，整型，太虚＆GT; {
私人上下文的背景下;
ProgressDialog PD;
公共FindFriendList（上下文的背景下）{
this.context =背景;
}
@覆盖
在preExecute保护无效（）{
super.on preExecute（）;
PD = ProgressDialog.show（上下文，，同步数据服务器本地内容。）;
}
@覆盖
保护无效doInBackground（整数... PARAMS）{
//getData("https://api.twitter.com/1/followers/ids.json?screen_name="+TwitterApp.UserName）;
的for（int i = 0; I＆LT; Friends_ID.size（）;我++）{
getmethodFriendprofile（Friends_ID.get（ⅰ））;
}
返回null;
}
@覆盖
保护无效onPostExecute（无效的结果）{
PD.dismiss（）;
}
}
公共无效getmethodFriendprofile（字符串FriendsID）{
Log.d（USER_ID，： - + FriendsID）;
字符串WEBURL ="https://api.twitter.com/1/users/lookup.json?user_id="+FriendsID+",twitter&include_entities=true";
Log.d（URL，： - + WEBURL）;
HttpClient的HttpClient的=新DefaultHttpClient（）;
HTTPGET HTTPGET =新HTTPGET（WEBURL）;
尝试 {
HTT presponse HTT presponse = httpClient.execute（HTTPGET）;
InputStream中的InputStream = HTT presponse.getEntity（）的getContent（）。
InputStreamReader的InputStreamReader的=新的InputStreamReader（InputStream的）;
BufferedReader中的BufferedReader =新的BufferedReader（InputStreamReader的）;
StringBuilder的StringBuilder的=新的StringBuilder（）;
字符串bufferedStrChunk = NULL;
而（（bufferedStrChunk = bufferedReader.readLine（））！= NULL）{
stringBuilder.append（bufferedStrChunk）;
}
Firendslist_Detail（stringBuilder.toString（））;
}赶上（ClientProtocolException CPE）{
的System.out.println（异常产生CAZ的HTT presponse：+ CPE）;
cpe.printStackTrace（）;
}赶上（IOException异常IOE）{
的System.out.println（第二异常产生的HTT presponse CAZ：+ IOE）;
ioe.printStackTrace（）;
}
}
公共无效Firendslist_Detail（字符串响应）{
尝试{
JSONArray jsonarray =新JSONArray（响应）;
的JSONObject的JSONObject = jsonarray.getJSONObject（0）;
字符串Friendid_ = jsonobject.getString（ID）;
串Friendpic_ = jsonobject.getString（profile_image_url）;
字符串Friendname_ = jsonobject.getString（姓名）;
串FriendScreename_ = jsonobject.getString（screen_name）;
}赶上（例外五）{
Log.d（A3，7）;
}
}
//现在u必须得到朋友ScreenName链接（FriendScreename _）。这ScreenName链接使用了后推到paticuler朋友
公众诠释postToTwitteragain（最后弦乐味精，字符串FriendScreenname）{
尝试 {
字符串消息= MSG +\ u0040+ FriendScreenname; //有有之间@和Scrrenname UNI code没有空格
ConfigurationBuilder confbuilder =新ConfigurationBuilder（）;
confbuilder.setOAuthAccessToken(TwitterSession.token).setOAuthAccessTokenSecret(TwitterSession.tokenSecret)
.setOAuthConsumerKey（twitter_consumer_key）.setOAuthConsumerSecret（twitter_secret_key）;
叽叽喳喳叽叽喳喳=新TwitterFactory().getOAuthAuthorizedInstance(twitter_consumer_key,twitter_secret_key,TwitterApp.mAccessToken);
Log.d（回顾大小，检讨+ message.length（））;
状态状态=（状态）twitter.updateStatus（消息）;
Log.d（状态，：+ status.toString（））;
返回1;
}赶上（例外五）{
e.printStackTrace（）;
返回0;
}
}
//微博班
公共类TwitterApp {
私人微博mTwitter;
私有静态TwitterSession mSession;
公共静态AccessToken mAccessToken;
私人CommonsHttpOAuthConsumer mHttpOauthConsumer;
私人OAuthProvider mHttpOauthprovider;
私人字符串mConsumerKey;
私人字符串mSecretKey;
私人ProgressDialog mProgressDlg;
私人TwDialogListener mListener;
私人上下文的背景下;
私有静态最后字符串变量=TwitterApp;
静态字符串oauth_verifier;
受保护的静态字符串username = NULL，UeserID = NULL;
静态字符串OAUTH_CALLBACK_URL =twitterapp：//连接;
公共静态最后弦乐REQUEST_URL =https://api.twitter.com/oauth/request_token;
公共静态最后弦乐ACCESS_URL =http://api.twitter.com/oauth/access_token;
公共静态最后弦乐AUTHORIZE_URL =http://api.twitter.com/oauth/authorize;
公共TwitterApp（上下文的背景下，字符串consumerKey，字符串SecretKey的）{
this.context =背景;
mTwitter =新TwitterFactory（）的getInstance（）。
mSession =新TwitterSession（上下文）;
mProgressDlg =新ProgressDialog（上下文）;
mProgressDlg.requestWindowFeature（Window.FEATURE_NO_TITLE）;
mConsumerKey = consumerKey;
mSecretKey = SecretKey的;
mHttpOauthConsumer =新CommonsHttpOAuthConsumer（mConsumerKey，mSecretKey）;
mHttpOauthprovider =新DefaultOAuthProvider（REQUEST_URL，ACCESS_URL，AUTHORIZE_URL）;
mAccessToken = mSession.getAccessToken（）;
configureToken（）;
}
公共无效使用setListener（TwDialogListener监听器）{
mListener =侦听器;
}
私人无效configureToken（）{
如果（mAccessToken！= NULL）{
mTwitter.setOAuthConsumer（mConsumerKey，mSecretKey）;
mTwitter.setOAuthAccessToken（mAccessToken）;
}
}
公共布尔hasAccessToken（）{
返回（mAccessToken == NULL）？假：真的;
}
公共静态无效resetAccessToken（）{
如果（mAccessToken！= NULL）{
mSession.resetAccessToken（）;
mAccessToken = NULL;
}
}
公共静态无效logoutTwitter（上下文的背景下）{
resetAccessToken（）;
@燮pressWarnings（未使用）
CookieSyncManager cookieSyncMngr = CookieSyncManager.createInstance（上下文）;
CookieManager cookieManager = CookieManager.getInstance（）;
cookieManager.removeAllCookie（）;
}
公共字符串getUsername（）{
返回mSession.getUsername（）;
}
公共无效updateStatus（字符串状态）抛出异常{
尝试 {
mTwitter.updateStatus（状态）;
}赶上（TwitterException E）{
扔ê;
}
}
公共无效授权（）{
mProgressDlg.setMessage（初始化...）;
mProgressDlg.show（）;
新的Thread（）{
@覆盖
公共无效的run（）{
字符串authUrl =;
诠释了什么= 1;
尝试 {
authUrl = mHttpOauthprovider.retrieveRequestToken（mHttpOauthConsumer，OAUTH_CALLBACK_URL）;
什么= 0;
Log.d（TAG，请求令牌网址+ authUrl）;
}赶上（例外五）{
Log.d（TAG，无法获得请求令牌）;
e.printStackTrace（）;
}
mHandler.sendMessage（mHandler.obtainMessage（什么，1，0，authUrl））;
}
}。开始（）;
}
公共无效processToken（字符串callbackUrl）{
mProgressDlg.setMessage（定型化...）;
mProgressDlg.show（）;
最后弦乐验证= getVerifier（callbackUrl）;
新的Thread（）{
@覆盖
公共无效的run（）{
诠释了什么= 1;
尝试 {
mHttpOauthprovider.retrieveAccessToken（mHttpOauthConsumer，验证）;
mAccessToken =新AccessToken（mHttpOauthConsumer.getToken（），mHttpOauthConsumer.getTokenSecret（））;
configureToken（）;
用户USER = mTwitter.verifyCredentials（）;
mSession.storeAccessToken（mAccessToken，user.getName（））;
用户名= user.getName（）;
Log.d（用户名，+用户名）;
Log.d（用户ID，+ user.getId（））;
HttpParameters params1 = mHttpOauthprovider.getResponseParameters（）;
串screen_name = params1.getFirst（screen_name）;
Log.d（screen_name＆GT;＆GT;＆GT;＆GT;＆GT;＆GT;＆GT;＆gt;中，screen_name）;
oauth_verifier =验证;
什么= 0;
}赶上（例外五）{
Log.d（TAG，错误获取访问令牌）;
e.printStackTrace（）;
}
mHandler.sendMessage（mHandler.obtainMessage（什么，2，0））;
}
}。开始（）;
}
私人字符串getVerifier（字符串callbackUrl）{
串验证=;
尝试 {
callbackUrl = callbackUrl.replace（twitterapp，HTTP）;
网址URL =新的URL（callbackUrl）;
查询字符串= url.getQuery（）;
String数组[] = query.split（＆安培;）;
对于（String参数：数组）{
串v [] = parameter.split（=）;
如果（URLDe coder.de code（V [0]）。等于（oauth.signpost.OAuth.OAUTH_VERIFIER））{
验证= URLDe coder.de code（V [1]）;
打破;
}
}
}赶上（MalformedURLException异常E）{
e.printStackTrace（）;
}
返回验证;
}
私人无效showLoginDialog（字符串URL）{
最后TwDialogListener监听器=新TwDialogListener（）{
@覆盖
公共无效的onComplete（字符串值）{
processToken（值）;
}
@覆盖
公共无效onerror的（字符串值）{
mListener.onError（打开授权页面失败）;
}
};
新TwitterDialog（背景下，网址，监听器）.show（）;
}
@燮pressLint（HandlerLeak）
私人处理程序mHandler =新的处理程序（）{
@覆盖
公共无效的handleMessage（信息MSG）{
mProgressDlg.dismiss（）;
如果（msg.what == 1）{
如果（msg.arg1 == 1）
mListener.onError（错误获取请求令牌）;
其他
mListener.onError（错误获得访问令牌）;
} 其他 {
如果（msg.arg1 == 1）
showLoginDialog（（字符串）msg.obj）;
其他
mListener.onComplete（）;
}
}
};
公共接口TwDialogListener {
无效的onComplete（字符串值）;
无效的onError（字符串值）;
}
}
TwitterDialog类
公共类TwitterDialog扩展对话框{
静态最终浮动[] DIMENSIONS_LANDSCAPE = {460，260};
静态最终浮动[] DIMENSIONS_PORTRAIT = {280，420};
静态最终FrameLayout.LayoutParams FILL =新FrameLayout.LayoutParams（ViewGroup.LayoutParams.FILL_PARENT，
ViewGroup.LayoutParams.FILL_PARENT）;
静态最终诠释保证金= 4;
静态最终诠释PADDING = 2;
私人字符串mUrl;
私人TwDialogListener mListener;
私人ProgressDialog mSpinner;
私人的WebView mWebView;
私人的LinearLayout mContent;
私人TextView的mTitle;
私有静态最后字符串变量=Twitter的的WebView;
公共TwitterDialog（上下文的背景下，字符串URL，TwDialogListener监听器）{
超（上下文）;
mUrl =网址;
mListener =侦听器;
}
@覆盖
保护无效的onCreate（包savedInstanceState）{
super.onCreate（savedInstanceState）;
mSpinner =新ProgressDialog（的getContext（））;
mSpinner.requestWindowFeature（Window.FEATURE_NO_TITLE）;
mSpinner.setMessage（载入中...）;
mContent =新的LinearLayout（的getContext（））;
mContent.setOrientation（LinearLayout.VERTICAL）;
setUpTitle（）;
setUpWebView（）;
显示显示= getWindow（）getWindowManager（）getDefaultDisplay（）。
最终浮动规模=的getContext（）getResources（）getDisplayMetrics（）密度。;
浮动[]尺寸=（display.getWidth（）＆LT; display.getHeight（））？ DIMENSIONS_PORTRAIT：DIMENSIONS_LANDSCAPE;
addContentView（mContent，新FrameLayout.LayoutParams（（int）的（尺寸[0] *刻度+ 0.5F），
（int）的（尺寸[1] *刻度+ 0.5F）））;
}
私人无效setUpTitle（）{
requestWindowFeature（Window.FEATURE_NO_TITLE）;
可绘制图标=的getContext（）getResources（）getDrawable（R.drawable.twitter_icon）。
mTitle =新的TextView（的getContext（））;
mTitle.setText（推特）;
mTitle.setTextColor（Color.WHITE）;
mTitle.setTypeface（Typeface.DEFAULT_BOLD）;
mTitle.setBackgroundColor（0xFFbbd7e9）;
mTitle.setPadding（保证金+ PADDING，保证金，保证金，保证金）;
mTitle.setCompoundDrawablePadding（保证金+填充）;
mTitle.setCompoundDrawablesWithIntrinsicBounds（图标，NULL，NULL，NULL）;
mContent.addView（mTitle）;
}
私人无效setUpWebView（）{
mWebView =新的WebView（的getContext（））;
mWebView.setVerticalScrollBarEnabled（假）;
mWebView.setHorizontalScrollBarEnabled（假）;
mWebView.setWebViewClient（新TwitterWebViewClient（））;
mWebView.getSettings（）setJavaScriptEnabled（真）。
mWebView.loadUrl（mUrl）;
mWebView.setLayoutParams（填）;
mContent.addView（mWebView）;
}
私有类TwitterWebViewClient扩展WebViewClient {
@覆盖
公共布尔shouldOverrideUrlLoading（web视图查看，字符串URL）{
Log.d（TAG，重定向URL+网址）;
如果（url.startsWith（TwitterApp.OAUTH_CALLBACK_URL））{
mListener.onComplete（URL）;
TwitterDialog.this.dismiss（）;
返回true;
}否则，如果（url.startsWith（授权））{
返回false;
}
返回true;
}
@覆盖
公共无效onReceivedError（web视图来看，INT错误code，字符串描述，字符串failingUrl）{
Log.d（TAG，页面错误：+说明）;
super.onReceivedError（查看，错误code，说明，failingUrl）;
mListener.onError（介绍）;
TwitterDialog.this.dismiss（）;
}
@覆盖
公共无效onPageStarted（web视图查看，字符串URL，位图图标）{
Log.d（TAG，加载URL：+网址）;
super.onPageStarted（查看，网址，网站图标）;
mSpinner.show（）;
}
@覆盖
公共无效onPageFinished（web视图查看，字符串URL）{
super.onPageFinished（查看，网址）;
字符串标题= mWebView.getTitle（）;
如果（标题= NULL和放大器;！＆安培; title.length（）0）{
mTitle.setText（职称）;
}
mSpinner.dismiss（）;
}
}
} **
TwitterSession
公共类TwitterSession {
私人共享preferences共享preF;
私人编辑器编辑;
静态字符串标记，tokenSecret;
私有静态最后弦乐TWEET_AUTH_KEY =AUTH_KEY;
私有静态最后弦乐TWEET_AUTH_SECRET_KEY =auth_secret_key;
私有静态最后弦乐TWEET_USER_NAME =用户名;
私有静态最后弦乐SHARED =Twitter_ preferences;
公共TwitterSession（上下文的背景下）{
共享preF = context.getShared preferences（共享，Context.MODE_PRIVATE）;
编辑=共享pref.edit（）;
}
公共无效storeAccessToken（AccessToken accessToken，字符串username）{
editor.putString（TWEET_AUTH_KEY，accessToken.getToken（））;
editor.putString（TWEET_AUTH_SECRET_KEY，accessToken.getTokenSecret（））;
editor.putString（TWEET_USER_NAME，用户名）;
editor.commit（）;
}
公共无效resetAccessToken（）{
editor.putString（TWEET_AUTH_KEY，NULL）;
editor.putString（TWEET_AUTH_SECRET_KEY，NULL）;
editor.putString（TWEET_USER_NAME，NULL）;
editor.commit（）;
}
公共字符串getUsername（）{
返回共享pref.getString（TWEET_USER_NAME，）;
}
公共AccessToken getAccessToken（）{
令牌=共享pref.getString（TWEET_AUTH_KEY，NULL）;
tokenSecret =共享pref.getString（TWEET_AUTH_SECRET_KEY，NULL）;
如果（标记=空＆放大器;！＆安培;！tokenSecret = NULL）
返回新AccessToken（令牌，tokenSecret）;
其他
返回null;
}
}
以下jar文件使用
- 路标-commonshttp4-1.2.1.1.jar
- 路标核-1.2.1.1.jar
- twitter4j核-2.1.11.jar
在哪里。 Friend_ID为String的ArrayList .. 我希望这code能帮助ü。享受这code！
I want to post tweet to following users of a Authenticate user.For authenticate using Twitter-4j library .I have get list(Name & id) of following users but not able to post tweet without open dialog.I am usingthis link for authenticate
Question-How directly post tweet to following users of a authenticate user in android wihout open Tweet dialog box(Message Dialog)
1. on twitterButton click a new Activity open with webview
twitterButton=(Button) findViewById(R.id.twitter);
twitterButton.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
// TODO Auto-generated method stub
mTwitter = new TwitterFactory().getInstance();
mRequestToken = null;
mTwitter.setOAuthConsumer(TwitterConstants.CONSUMER_KEY,
TwitterConstants.CONSUMER_SECRET);
String callbackURL = getResources().getString(
R.string.twitter_callback);
try {
mRequestToken = mTwitter.getOAuthRequestToken(callbackURL);
System.out.println("URL"
+ mRequestToken.getAuthenticationURL());
} catch (TwitterException e) {
e.printStackTrace();
}
Intent i = new Intent(MMSExampleActivity.this,
TwitterScreen.class);
i.putExtra("URL", mRequestToken.getAuthenticationURL());
System.out.println("Url ==== "
+ mRequestToken.getAuthenticationURL());
startActivityForResult(i, TWITTER_AUTH);
}
});
2. in onActivityResult(int requestCode, int resultCode, Intent data) method
if (resultCode == Activity.RESULT_OK) {
String oauthVerifier = (String) data.getExtras().get(
"oauth_verifier");
AccessToken at = null;
try {
// Pair up our request with the response
at = mTwitter.getOAuthAccessToken(mRequestToken,
oauthVerifier);
accessToken = at.getToken();
System.out.println("access token" + accessToken);
accessTokenSecret = at.getTokenSecret();
getFollowers();
Intent twitterFriendIntent=new Intent(MMSExampleActivity.this,TwitterFriends.class);
twitterFriendIntent.putExtra("twitterfriends", twitterFriends);
startActivity(twitterFriendIntent);
} catch (TwitterException e) {
System.out.println("e........");
e.printStackTrace();
}
}
3. Getting following userList
public void getFollowers()
{
ConfigurationBuilder builder = new ConfigurationBuilder();
builder.setOAuthConsumerKey(TwitterConstants.CONSUMER_KEY);
builder.setOAuthConsumerSecret(TwitterConstants.CONSUMER_SECRET);
builder.setOAuthAccessToken(accessToken);
builder.setOAuthAccessTokenSecret(accessTokenSecret);
Configuration conf = builder.build();
twitter = new TwitterFactory(conf).getInstance();
try {
long lCursor = -1;
IDs friendsIDs = twitter.getFriendsIDs(twitter.getId(), lCursor);
IDs followersIds=twitter.getFollowersIDs(twitter.getId(), lCursor);
System.out.println(twitter.showUser(twitter.getId()).getName());
System.out.println("==========================");
do
{
for (long i : friendsIDs.getIDs())
{
FriendList friendListObj=new FriendList();
friendListObj.setTwitterId(i);
friendListObj.setTwitterUsername(twitter.showUser(i).getName());
friendListObj.setTwitterUrl(twitter.showUser(i).getScreenName());
twitterFriends.add(friendListObj);
System.out.println("follower ID #" + i);
System.out.println(twitter.showUser(i).getName());
System.out.println(twitter.showUser(i).getProfileImageURL());
System.out.println(twitter.showUser(i).getURL());
}
}while(friendsIDs.hasNext());
} catch (IllegalStateException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (TwitterException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
4. Code for post tweets
public void updateStatus( String messageToPost) {
ConfigurationBuilder builder = new ConfigurationBuilder();
builder.setOAuthConsumerKey(TwitterConstants.CONSUMER_KEY);
builder.setOAuthConsumerSecret(TwitterConstants.CONSUMER_SECRET);
builder.setOAuthAccessToken(accessToken);
builder.setOAuthAccessTokenSecret(accessTokenSecret);
Configuration conf = builder.build();
Twitter twitter = new TwitterFactory(conf).getInstance();
System.out.println("in update status");
try {
// twitter.updateStatus("Hello World!");
StatusUpdate status = new StatusUpdate(messageToPost);
System.out.println("Length of Message is = = = "
+ messageToPost.trim().length());
System.out.println("App" + file);
status.setMedia(file);
System.out.println("App" + file.exists());
twitter.updateStatus(status);
System.out.println("App" + file);
} catch (TwitterException e) {
System.err.println("Error occurred while updating the status!");
e.printStackTrace();
}
}
解决方案
U have got Twitter Friends ID ... now get Friends Detail(basically Screen Name)
public class FindFriendList extends AsyncTask<Integer, Integer, Void>{
private Context context;
ProgressDialog PD ;
public FindFriendList(Context context) {
this.context = context;
}
@Override
protected void onPreExecute() {
super.onPreExecute();
PD = ProgressDialog.show(context,"","sync Data Server to Local data.");
}
@Override
protected Void doInBackground(Integer... params) {
//getData("https://api.twitter.com/1/followers/ids.json?screen_name="+TwitterApp.UserName);
for (int i = 0; i < Friends_ID.size(); i++) {
getmethodFriendprofile(Friends_ID.get(i));
}
return null;
}
@Override
protected void onPostExecute(Void result) {
PD.dismiss();
}
}
public void getmethodFriendprofile(String FriendsID) {
Log.d("user_ID",":-"+FriendsID);
String weburl ="https://api.twitter.com/1/users/lookup.json?user_id="+FriendsID+",twitter&include_entities=true";
Log.d("url",":-"+weburl);
HttpClient httpClient = new DefaultHttpClient();
HttpGet httpGet = new HttpGet(weburl);
try {
HttpResponse httpResponse = httpClient.execute(httpGet);
InputStream inputStream = httpResponse.getEntity().getContent();
InputStreamReader inputStreamReader = new InputStreamReader(inputStream);
BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
StringBuilder stringBuilder = new StringBuilder();
String bufferedStrChunk = null;
while((bufferedStrChunk = bufferedReader.readLine()) != null){
stringBuilder.append(bufferedStrChunk);
}
Firendslist_Detail(stringBuilder.toString());
} catch (ClientProtocolException cpe) {
System.out.println("Exception generates caz of httpResponse :" + cpe);
cpe.printStackTrace();
} catch (IOException ioe) {
System.out.println("Second exception generates caz of httpResponse :" + ioe);
ioe.printStackTrace();
}
}
public void Firendslist_Detail(String response){
try{
JSONArray jsonarray = new JSONArray(response);
JSONObject jsonobject = jsonarray.getJSONObject(0);
String Friendid_ = jsonobject.getString("id");
String Friendpic_ = jsonobject.getString("profile_image_url");
String Friendname_ = jsonobject.getString("name");
String FriendScreename_ = jsonobject.getString("screen_name");
}catch (Exception e) {
Log.d("A3", "7");
}
}
// now u have got Friend ScreenName (FriendScreename_).this ScreenName use for post tweet to paticuler Friend
public int postToTwitteragain(final String msg,String FriendScreenname) {
try {
String message = msg+"\u0040"+FriendScreenname; //there has not white space between unicode of @ and Scrrenname
ConfigurationBuilder confbuilder = new ConfigurationBuilder();
confbuilder.setOAuthAccessToken(TwitterSession.token).setOAuthAccessTokenSecret(TwitterSession.tokenSecret)
.setOAuthConsumerKey(twitter_consumer_key).setOAuthConsumerSecret(twitter_secret_key);
Twitter twitter = new TwitterFactory().getOAuthAuthorizedInstance(twitter_consumer_key,twitter_secret_key,TwitterApp.mAccessToken);
Log.d("review size","review"+message.length());
Status status = (Status) twitter.updateStatus(message);
Log.d("status",":"+status.toString());
return 1;
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
//Twitter class
public class TwitterApp {
private Twitter mTwitter;
private static TwitterSession mSession;
public static AccessToken mAccessToken;
private CommonsHttpOAuthConsumer mHttpOauthConsumer;
private OAuthProvider mHttpOauthprovider;
private String mConsumerKey;
private String mSecretKey;
private ProgressDialog mProgressDlg;
private TwDialogListener mListener;
private Context context;
private static final String TAG = "TwitterApp";
static String oauth_verifier ;
protected static String UserName = null,UeserID = null;
static String OAUTH_CALLBACK_URL = "twitterapp://connect";
public static final String REQUEST_URL = "https://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";
public TwitterApp(Context context, String consumerKey, String secretKey) {
this.context = context;
mTwitter = new TwitterFactory().getInstance();
mSession = new TwitterSession(context);
mProgressDlg = new ProgressDialog(context);
mProgressDlg.requestWindowFeature(Window.FEATURE_NO_TITLE);
mConsumerKey = consumerKey;
mSecretKey = secretKey;
mHttpOauthConsumer = new CommonsHttpOAuthConsumer(mConsumerKey, mSecretKey);
mHttpOauthprovider = new DefaultOAuthProvider(REQUEST_URL,ACCESS_URL,AUTHORIZE_URL);
mAccessToken = mSession.getAccessToken();
configureToken();
}
public void setListener(TwDialogListener listener) {
mListener = listener;
}
private void configureToken() {
if (mAccessToken != null) {
mTwitter.setOAuthConsumer(mConsumerKey, mSecretKey);
mTwitter.setOAuthAccessToken(mAccessToken);
}
}
public boolean hasAccessToken() {
return (mAccessToken == null) ? false : true;
}
public static void resetAccessToken() {
if (mAccessToken != null) {
mSession.resetAccessToken();
mAccessToken = null;
}
}
public static void logoutTwitter(Context context) {
resetAccessToken();
@SuppressWarnings("unused")
CookieSyncManager cookieSyncMngr = CookieSyncManager.createInstance(context);
CookieManager cookieManager = CookieManager.getInstance();
cookieManager.removeAllCookie();
}
public String getUsername() {
return mSession.getUsername();
}
public void updateStatus(String status) throws Exception {
try {
mTwitter.updateStatus(status);
} catch (TwitterException e) {
throw e;
}
}
public void authorize() {
mProgressDlg.setMessage("Initializing ...");
mProgressDlg.show();
new Thread() {
@Override
public void run() {
String authUrl = "";
int what = 1;
try {
authUrl = mHttpOauthprovider.retrieveRequestToken(mHttpOauthConsumer, OAUTH_CALLBACK_URL);
what = 0;
Log.d(TAG, "Request token url " + authUrl);
} catch (Exception e) {
Log.d(TAG, "Failed to get request token");
e.printStackTrace();
}
mHandler.sendMessage(mHandler.obtainMessage(what, 1, 0, authUrl));
}
}.start();
}
public void processToken(String callbackUrl) {
mProgressDlg.setMessage("Finalizing ...");
mProgressDlg.show();
final String verifier = getVerifier(callbackUrl);
new Thread() {
@Override
public void run() {
int what = 1;
try {
mHttpOauthprovider.retrieveAccessToken(mHttpOauthConsumer, verifier);
mAccessToken = new AccessToken(mHttpOauthConsumer.getToken(), mHttpOauthConsumer.getTokenSecret());
configureToken();
User user = mTwitter.verifyCredentials();
mSession.storeAccessToken(mAccessToken, user.getName());
UserName = user.getName();
Log.d("user name",""+UserName);
Log.d("user ID",""+user.getId());
HttpParameters params1 = mHttpOauthprovider.getResponseParameters();
String screen_name = params1.getFirst("screen_name");
Log.d("screen_name >>>>>>>>", screen_name);
oauth_verifier = verifier;
what = 0;
} catch (Exception e){
Log.d(TAG, "Error getting access token");
e.printStackTrace();
}
mHandler.sendMessage(mHandler.obtainMessage(what, 2, 0));
}
}.start();
}
private String getVerifier(String callbackUrl) {
String verifier = "";
try {
callbackUrl = callbackUrl.replace("twitterapp", "http");
URL url = new URL(callbackUrl);
String query = url.getQuery();
String array[] = query.split("&");
for (String parameter : array) {
String v[] = parameter.split("=");
if (URLDecoder.decode(v[0]).equals(oauth.signpost.OAuth.OAUTH_VERIFIER)) {
verifier = URLDecoder.decode(v[1]);
break;
}
}
} catch (MalformedURLException e) {
e.printStackTrace();
}
return verifier;
}
private void showLoginDialog(String url) {
final TwDialogListener listener = new TwDialogListener() {
@Override
public void onComplete(String value) {
processToken(value);
}
@Override
public void onError(String value) {
mListener.onError("Failed opening authorization page");
}
};
new TwitterDialog(context, url, listener).show();
}
@SuppressLint("HandlerLeak")
private Handler mHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
mProgressDlg.dismiss();
if (msg.what == 1) {
if (msg.arg1 == 1)
mListener.onError("Error getting request token");
else
mListener.onError("Error getting access token");
} else {
if (msg.arg1 == 1)
showLoginDialog((String) msg.obj);
else
mListener.onComplete("");
}
}
};
public interface TwDialogListener {
void onComplete(String value);
void onError(String value);
}
}
TwitterDialog class
public class TwitterDialog extends Dialog {
static final float[] DIMENSIONS_LANDSCAPE = {460, 260};
static final float[] DIMENSIONS_PORTRAIT = {280, 420};
static final FrameLayout.LayoutParams FILL = new FrameLayout.LayoutParams(ViewGroup.LayoutParams.FILL_PARENT,
ViewGroup.LayoutParams.FILL_PARENT);
static final int MARGIN = 4;
static final int PADDING = 2;
private String mUrl;
private TwDialogListener mListener;
private ProgressDialog mSpinner;
private WebView mWebView;
private LinearLayout mContent;
private TextView mTitle;
private static final String TAG = "Twitter-WebView";
public TwitterDialog(Context context, String url, TwDialogListener listener) {
super(context);
mUrl = url;
mListener = listener;
}
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
mSpinner = new ProgressDialog(getContext());
mSpinner.requestWindowFeature(Window.FEATURE_NO_TITLE);
mSpinner.setMessage("Loading...");
mContent = new LinearLayout(getContext());
mContent.setOrientation(LinearLayout.VERTICAL);
setUpTitle();
setUpWebView();
Display display = getWindow().getWindowManager().getDefaultDisplay();
final float scale = getContext().getResources().getDisplayMetrics().density;
float[] dimensions = (display.getWidth() < display.getHeight()) ? DIMENSIONS_PORTRAIT : DIMENSIONS_LANDSCAPE;
addContentView(mContent, new FrameLayout.LayoutParams((int) (dimensions[0] * scale + 0.5f),
(int) (dimensions[1] * scale + 0.5f)));
}
private void setUpTitle() {
requestWindowFeature(Window.FEATURE_NO_TITLE);
Drawable icon = getContext().getResources().getDrawable(R.drawable.twitter_icon);
mTitle = new TextView(getContext());
mTitle.setText("Twitter");
mTitle.setTextColor(Color.WHITE);
mTitle.setTypeface(Typeface.DEFAULT_BOLD);
mTitle.setBackgroundColor(0xFFbbd7e9);
mTitle.setPadding(MARGIN + PADDING, MARGIN, MARGIN, MARGIN);
mTitle.setCompoundDrawablePadding(MARGIN + PADDING);
mTitle.setCompoundDrawablesWithIntrinsicBounds(icon, null, null, null);
mContent.addView(mTitle);
}
private void setUpWebView() {
mWebView = new WebView(getContext());
mWebView.setVerticalScrollBarEnabled(false);
mWebView.setHorizontalScrollBarEnabled(false);
mWebView.setWebViewClient(new TwitterWebViewClient());
mWebView.getSettings().setJavaScriptEnabled(true);
mWebView.loadUrl(mUrl);
mWebView.setLayoutParams(FILL);
mContent.addView(mWebView);
}
private class TwitterWebViewClient extends WebViewClient {
@Override
public boolean shouldOverrideUrlLoading(WebView view, String url) {
Log.d(TAG, "Redirecting URL " + url);
if (url.startsWith(TwitterApp.OAUTH_CALLBACK_URL)) {
mListener.onComplete(url);
TwitterDialog.this.dismiss();
return true;
} else if (url.startsWith("authorize")) {
return false;
}
return true;
}
@Override
public void onReceivedError(WebView view, int errorCode, String description, String failingUrl) {
Log.d(TAG, "Page error: " + description);
super.onReceivedError(view, errorCode, description, failingUrl);
mListener.onError(description);
TwitterDialog.this.dismiss();
}
@Override
public void onPageStarted(WebView view, String url, Bitmap favicon) {
Log.d(TAG, "Loading URL: " + url);
super.onPageStarted(view, url, favicon);
mSpinner.show();
}
@Override
public void onPageFinished(WebView view, String url) {
super.onPageFinished(view, url);
String title = mWebView.getTitle();
if (title != null && title.length() > 0) {
mTitle.setText(title);
}
mSpinner.dismiss();
}
}
}**
TwitterSession
public class TwitterSession {
private SharedPreferences sharedPref;
private Editor editor;
static String token,tokenSecret;
private static final String TWEET_AUTH_KEY = "auth_key";
private static final String TWEET_AUTH_SECRET_KEY = "auth_secret_key";
private static final String TWEET_USER_NAME = "user_name";
private static final String SHARED = "Twitter_Preferences";
public TwitterSession(Context context) {
sharedPref = context.getSharedPreferences(SHARED, Context.MODE_PRIVATE);
editor = sharedPref.edit();
}
public void storeAccessToken(AccessToken accessToken, String username) {
editor.putString(TWEET_AUTH_KEY, accessToken.getToken());
editor.putString(TWEET_AUTH_SECRET_KEY, accessToken.getTokenSecret());
editor.putString(TWEET_USER_NAME, username);
editor.commit();
}
public void resetAccessToken() {
editor.putString(TWEET_AUTH_KEY, null);
editor.putString(TWEET_AUTH_SECRET_KEY, null);
editor.putString(TWEET_USER_NAME, null);
editor.commit();
}
public String getUsername() {
return sharedPref.getString(TWEET_USER_NAME, "");
}
public AccessToken getAccessToken() {
token = sharedPref.getString(TWEET_AUTH_KEY, null);
tokenSecret = sharedPref.getString(TWEET_AUTH_SECRET_KEY, null);
if (token != null && tokenSecret != null)
return new AccessToken(token, tokenSecret);
else
return null;
}
}
following jar file use
- signpost-commonshttp4-1.2.1.1.jar
- signpost-core-1.2.1.1.jar
- twitter4j-core-2.1.11.jar
where . Friend_ID is String Arraylist.. I hope this code can help u .Enjoy This code !
这篇关于在Android中 - 如何直接张贴鸣叫继Android的用户验证用户无需打开推对话框（消息对话框）的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
查看全文
