首页 > 代码库 > 接入新浪、腾讯微博和人人网的Android客户端实例 接入新浪、腾讯微博和人人网的Android客户端实例

接入新浪、腾讯微博和人人网的Android客户端实例 接入新浪、腾讯微博和人人网的Android客户端实例

2024-07-11 00:30:31   226人阅读

      做了个Android项目，需要接入新浪微博，实现时也顺带着研究了下腾讯微博和人人网的Android客户端接入，本文就跟大家分享下三者的Android客户端接入方法。

       一、实例概述

       说白了，接入微博就是让你的应用程序可以调用新浪微博，腾讯微博和人人网的api，实现微博发送，分享给好友等等的功能啦。当然也可以实现让你的客户端使用微博账号进行登录。我们这篇文章要讲的就是访问这些社交平台提供的api的时候比较关键的一步，获取调用api接口的token，token可以理解为我们的客户端程序与社交平台api交互的令牌。

       二、官方教程

       学习东西，当然是官方的东西最好了。下面我们就简单说说接入新浪，腾讯微博以及人人网的官方教程吧。同学们也可以自行去看官方的教程，那么我下面写的东西就可以忽略不计了。

       新浪微博 api：http://open.weibo.com/wiki/%E9%A6%96%E9%A1%B5

       首先，当然你得有一个新浪微博的账号啦。然后就是注册应用啊等等一代堆东西，自己去 开发指南--新手引导 中看吧。然后，就要填写我们的信息了。这里要注意授权页的填写，在 我的应用--应用信息--高级信息--授权回调页 这里，如下图1。最后，就是如何对我们的客户端程序进行授权了。新浪微博的授权机制说明如下：大部分API的访问如发表微博、获取私信，关注都需要用户身份。目前新浪微博开放平台用户身份鉴权有OAuth2.0和Basic Auth（仅用于应用所属开发者调试接口）两种方式。我们这里采用的是OAuth2.0的授权机制。

       如何获取token，我们将在下面的文章中结合代码进行讲解。    

设置授权回调页

图1 设置授权回调页

       腾讯微博  api：http://dev.t.qq.com/

       腾讯微博的应用申请和新浪微博的类似，它也有一个授权回调页。不过它不是这个名字，它的名字是：应用网址。为简单起见，我们这里也使用默认的地址，即：http://www.tencent.com/zh-cn/index.shtml 其他的和腾讯微博差不多，就不赘述了。腾讯微博提供了OAuth 1.0a,OAuth2.0和OpenId&OpenKey授权方式，本人中采用的是OAuth2.0授权方式，其他的方式同学们自行研究。

       人人网  api：http://dev.renren.com/    人人网使用OAuth 2.0作为验证与授权协议。

       人人网目前有一个移动开发者平台，专门为移动应用和HTML5应用提供更简洁的授权接口，简单易用，称为人人移动开发者中心。地址如下：

       http://dev.mobile.renren.com/home/show

     三、关于OAuth2.0

       本人比较懒，就不把概念贴在这里了。自己百度去吧，百度百科中有这样的一句概括：OAuth 2.0关注客户端开发者的简易性，同时为Web应用，桌面应用和手机，和起居室设备提供专门的认证流程。这里我们稍微说一下OAuth2.0的认证流程。

       在OAuth2.0的处理流程，主要分为以下四个步骤：

       1、得到授权码code

       2、获取access token

       3、通过access token,获取OpenID

       4、通过access token及OpenID调用API,获取用户授权信息

       上面是流程的大概四个步骤，在下面的流程示意图中会得到体现，这是我制作的一个幻灯片的流程图（文章最后会附上制作的OAuth幻灯片分享给大家），这里就直接截图下来进行讲解：

OAuth2.0 认证流程

图2 OAuth2.0 认证流程

       第一步：首先直接跳转至用户授权地址，即图示 Request User Url ，提示用户进行登录，并给予相关资源授权，得到唯一的Auth code，这里注意的是code只有10分钟的有效期，对于安全考虑，相对于OAuth1.0省了一步获取临时的Token，并且有效期也进行了控制，比1.0认证简化了很多，并安全一些；

       第二步：得到授权code后，这一步就是请求access token，通过 图示 Request access url ，生成得到数据Token；

       第三步：通过Access Token请求OpenID，openid是用户在此平台的唯一标识，通过 图示 Request info url 请求，然后得到OpenID；

       第四步：通过第二步得到的数据Token、第三步得到的OpenID及相关API，进行请求，获取用户授权资源信息。（我喜欢简洁明了，OAuth2.0认证流程就是这样，相信通过图示及讲解都能明白，若有不明白之处请留言）

       四、让你的应用程序访问社交平台api（获取token）

       注意要加相应的权限，文章后面会贴出清单文件中所需的权限。

       新浪微博授权：

       详细内容请参见新浪微博SDK中自带的文档：Android平台微博SDK说明文档.docx。它在SDK的工程目录下，所以你要导入SDK工程的时候主要把它去了。由于新浪微博给我们提供的SDK是以工程的方式给出的，所以我们需要引用它的工程才可以使用它提供的api。当然啦，这样放到实际环境中是不行的。所以我们可以将SDK下的相关文件拷贝到我们的自己的工程目录下即可，注意修改相应的东西。本人是这样做的，不知道还有没有更好的方式。具体的请看文章后面给出的demo。值得一提的是，人人网也是以这种方式提供SDK的，但是腾讯微博给我们提供的是JAR，这个看起来就简洁多了。这里顺便说一下覆盖的方法吧，就是将新浪微博给我们提供的SDK工程文件下的src和res文件夹拷贝到你自己的工程中覆盖原有的文件即可。

       环境准备好了，我们就可以开始进行代码的编写了。还是那句话，有官方教程在呢，同学们可以对着教程来练习，我下面只是结合代码简单的说一下。

Java代码
  1. //sina   CONSUMER_KEY、CONSUMER_SECRET替换成你自己应用的key和secret   
  2.     private static final String CONSUMER_KEY = "913917729";   
  3.     private static final String CONSUMER_SECRET = "32c47f37e4727ce9c0db1ceee12bf765";   
  4.     private String redirectUriSina="http://www.sina.com"; //授权回调页    与 我的应用--应用信息--高级信息 中一致   
  5.     OAuthV2 authV2 = null;//腾讯微博Oauth   
  6.     Renren renren = null;//renren   
  7.     File file = null;   
  8.     String basepath = "";   
  9.        
  10.     //tencent CLINETID、CLIENTSECRET替换成你自己应用的key和secret   
  11.     private static final String CLINETID = "801208558";   
  12.     private static final String CLIENTSECRET = "da6d09bb537559c37cb36561fd825346";   
  13.     //认证成功后浏览器会被重定向到这个url中  必须与注册时填写的一致   
  14.     private String redirectUriTen="http://www.tencent.com/zh-cn/index.shtml";    
  15.        
  16.     //renren API_KEY、SECRET_KEY替换成你自己应用的key和secret   
  17.     private static final String API_KEY = "b6f9602ab3714023b794d34b51639a99";   
  18.     private static final String SECRET_KEY = "f51ce08118014784a0579ba88730b6bd";   
  19.     private static final String APP_ID = "206681";//人人网还需要app_id  
  20.     private static final int RENREN_REQUEST_CODE = 123;   
  21.     String accessToken;  
Java代码
  1. //新浪微博认证   
  2.             Weibo weibo = Weibo.getInstance();   
  3.             if(!isOauthSina(weibo)){   
  4.                 weibo.setupConsumerConfig(CONSUMER_KEY, CONSUMER_SECRET);//设置你的key和secret   
  5.                 weibo.setRedirectUrl(redirectUriSina);   
  6.                 weibo.authorize(this, new OauthDialogListener());   
  7.             }else{   
  8.                 tv.setText("access_token : " + accessToken);   
  9.                 Toast.makeText(getApplicationContext(), "该用户已经授权", Toast.LENGTH_SHORT).show();   
  10.                 Intent intent = new Intent();   
  11.                 intent.putExtra("accessToken", accessToken);   
  12.                 intent.putExtra("flag", MyContent.SINA);   
  13.                 intent.setClass(InsertWeiboActivity.this, TestActivity.class);   
  14.                 startActivity(intent);   
  15.             }  

       isOauthSina方法如下，它的作用是判断用户是否已经对我们的应用进行了授权。

Java代码
  1. /**  
  2.      * 新浪微博 用户是否已经授权  
  3.      * @param weibo  
  4.      * @return  
  5.      */  
  6.     private boolean isOauthSina(Weibo weibo){   
  7.         boolean b = false;   
  8.         accessToken = getSharedPreferences("token", Context.MODE_PRIVATE).getString("access_token", "");   
  9.         if(weibo != null && !accessToken.equals("")){   
  10.             b = true;   
  11.         }   
  12.         return b;   
  13.     }  

       上面的两段代码中， 值得注意的地方是redirectUriSina，它是一个String类型的参数，值就是我们在之前提到过得那个授权回调页的地址。接着新浪微博将弹出一个授权页面的对话框，供用户输入用户名和密码（此处就不截图了）。在用户输入用户名和密码之后，它将被我们的OauthDialogListener类监听到，它的实现如下：

Java代码
  1. /**  
  2.      * 弹出新浪微博的授权页面  
  3.      * @author yanbin  
  4.      *  
  5.      */  
  6.     private class OauthDialogListener implements WeiboDialogListener{   
  7.         @Override  
  8.         public void onComplete(Bundle values) {   
  9.             String token = values.getString("access_token");   
  10.             String expires_in = values.getString("expires_in");   
  11.             tv.setText("access_token : " + token + "  expires_in: "  
  12.                     + expires_in);   
  13.             AccessToken accessToken = new AccessToken(token, CONSUMER_SECRET);   
  14.             SharedPreferences sf = getSharedPreferences("token", Context.MODE_PRIVATE);   
  15.             sf.edit().putString("access_token", accessToken != null ? accessToken.getToken() : "")   
  16.             .commit();   
  17. //          accessToken.setExpiresIn(expires_in);   
  18. //          Weibo.getInstance().setAccessToken(accessToken);   
  19.             Intent intent = new Intent();   
  20.             intent.putExtra("accessToken",accessToken.getToken());   
  21.             intent.putExtra("flag", MyContent.SINA);   
  22.             intent.setClass(InsertWeiboActivity.this, TestActivity.class);   
  23.             startActivity(intent);   
  24.         }   
  25.   
  26.         @Override  
  27.         public void onWeiboException(WeiboException e) {   
  28.             //未作处理   
  29.         }   
  30.   
  31.         @Override  
  32.         public void onError(DialogError e) {   
  33.             //未作处理   
  34.         }   
  35.   
  36.         @Override  
  37.         public void onCancel() {   
  38.             Toast.makeText(InsertWeiboActivity.this, "您已经取消授权", 1).show();   
  39.         }   
  40.     }  

       WeiboDialogListener中有一个回调方法，它会在用户输入正确的用户名和密码之后返回给我们的客户端程序获取新浪微博提供的api的令牌(这个东西很重要的，你调用新浪微博api的时候每次都必须把它带上)。接下来的工作就是保存此token供下次使用了。这里我们存储在SharedPreference中。至此，我们就获取了新浪微博的token，接下来就可以操作新浪微博api了，比如发布一条微博，可以试试哦。 

       腾讯微博授权： 

       腾讯微博授权的官方实例请看这里，http://wiki.open.t.qq.com/index.php/%E7%A7%BB%E5%8A%A8%E5%BA%94%E7%94%A8%E6%8E%A5%E5%85%A5/Android_SDK_V1.2。下面我们结合代码说说我们的实现。  首先第一步就是得到腾讯给我们提供的授权回调页，代码如下，由于要弹出OAuthV2AuthorizeWebView这个页面，所以要在清单文件中声明。

Java代码
  1. //判断用户是否已经授权   
  2. if(!isOauchTen()){   
  3.        //使用回调url来创建授权页面   
  4.        authV2 = new OAuthV2(redirectUriTen);   
  5.        authV2.setClientId(CLINETID);   
  6.        authV2.setClientSecret(CLIENTSECRET);   
  7.        //关闭OAuthV2Client中的默认开启的QHttpClient。   
  8.        OAuthV2Client.getQHttpClient().shutdownConnection();   
  9.        Intent intent = new Intent(InsertWeiboActivity.this, OAuthV2AuthorizeWebView.class);//创建Intent，使用WebView让用户授权   
  10.        intent.putExtra("oauth", authV2);   
  11.        startActivityForResult(intent,2);    
  12. }else{   
  13.        Toast.makeText(getApplicationContext(), "该用户已经授权", Toast.LENGTH_SHORT).show();   
  14.        Intent intent = new Intent();   
  15.        intent.putExtra("oauth", authV2);   
  16.        intent.putExtra("flag", MyContent.TENCENT);   
  17.        intent.setClass(InsertWeiboActivity.this, TestActivity.class);   
  18.        startActivity(intent);   
  19. }  

       这里我们看到了startActivityForResult，它会在用户输入完用户名和密码后执行OnActivityResult方法（包括了人人的实现），isOauthTen()方法的作用是判断用户是否已经授权过该应用。它们的代码如下：

       OnActivityResult()方法：

Java代码
  1. /**  
  2.     * 新浪微博和人人网的授权  
  3.     * 通过读取OAuthV2AuthorizeWebView返回的Intent，获取用户授权信息  
  4.     */  
  5.    @Override  
  6.    protected void onActivityResult(int requestCode, int resultCode, Intent data) {   
  7.     if (requestCode==2) {   
  8.         //腾讯微博授权   
  9.            if (resultCode==OAuthV2AuthorizeWebView.RESULT_CODE)    {   
  10.                OAuthV2 oAuth=(OAuthV2) data.getExtras().getSerializable("oauth");   
  11.                if(oAuth != null && oAuth.getStatus()==0){   
  12.                 Toast.makeText(getApplicationContext(), "登陆成功", Toast.LENGTH_SHORT).show();   
  13.                 //跳转到发微博的界面   
  14.                 Intent intent = new Intent();   
  15.                 intent.putExtra("accessToken", oAuth.getAccessToken());   
  16.                 intent.putExtra("oauth", oAuth);   
  17.                 intent.putExtra("flag", MyContent.TENCENT);   
  18.                 //将认证保存起来，使用对象流   
  19.                 FileOutputStream fos = null;   
  20.                 ObjectOutputStream oos = null;   
  21.                 try {   
  22.                     fos = new FileOutputStream(file);   
  23.                     oos = new ObjectOutputStream(fos);   
  24.                     oos.writeObject(oAuth);   
  25.                 } catch (FileNotFoundException e) {   
  26.                     e.printStackTrace();   
  27.                 } catch (IOException e) {   
  28.                     e.printStackTrace();   
  29.                 } finally{   
  30.                     if(oos != null){   
  31.                         try {   
  32.                             oos.close();   
  33.                             oos = null;   
  34.                         } catch (IOException e) {   
  35.                             e.printStackTrace();   
  36.                         }   
  37.                     if(fos != null){   
  38.                         try {   
  39.                             fos.close();   
  40.                             fos = null;   
  41.                         } catch (IOException e) {   
  42.                             e.printStackTrace();   
  43.                         }   
  44.                     }   
  45.                     }   
  46.                 }   
  47.                 intent.setClass(InsertWeiboActivity.this, TestActivity.class);   
  48.                 startActivity(intent);     
  49.                }   
  50.                else  
  51.                 Toast.makeText(getApplicationContext(), "登陆失败", Toast.LENGTH_SHORT).show();   
  52.            }else{   
  53.             Toast.makeText(getApplicationContext(), "授权失败", Toast.LENGTH_SHORT).show();   
  54.            }   
  55.        }else if(requestCode == RENREN_REQUEST_CODE){   
  56.         //人人网授权   
  57.         if (renren != null) {   
  58.             renren.authorizeCallback(requestCode, resultCode, data);   
  59.         }else{   
  60.             Toast.makeText(getApplicationContext(), "授权失败", Toast.LENGTH_SHORT).show();   
  61.         }   
  62.        }   
  63.    }  

       isOauchTen()方法：

Java代码
  1. /**  
  2.      * 腾讯微博接入是否已经验证  
  3.      * @return  
  4.      */  
  5.     private boolean isOauchTen() {   
  6.         boolean b = false;   
  7.         FileInputStream fis = null;   
  8.         ObjectInputStream ois = null;   
  9.         try {   
  10.             openFileOutput("aaa", Context.MODE_PRIVATE);   
  11.             persistTenOauth();   
  12.             fis = new FileInputStream(file);   
  13.             ois = new ObjectInputStream(fis);//此处抛出EOFException，原因是独到了流的末尾还是返回空，我们这里直接在异常中将标志位记为false即可。   
  14.             authV2 = (OAuthV2) ois.readObject();   
  15.             if(authV2 != null){   
  16.                 b = true;   
  17.             }   
  18.         } catch (Exception e) {   
  19.             b = false;   
  20.         } finally{   
  21.             if(ois != null){   
  22.                 try {   
  23.                     ois.close();   
  24.                     ois = null;   
  25.                 } catch (Exception e2) {   
  26.                     e2.printStackTrace();   
  27.                 }   
  28.             }   
  29.             if(fis != null){   
  30.                 try {   
  31.                     fis.close();   
  32.                     fis = null;   
  33.                 } catch (Exception e2) {   
  34.                     e2.printStackTrace();   
  35.                 }   
  36.             }   
  37.                    
  38.         }   
  39.         return b;   
  40.     }  

      persistTenOauth()方法的作用是将我们获取到的token存储起来，由于调用腾讯微博api需要Token对象，没有办法所以我们只有将Token对象存起来，这里使用对象流的方式，具体实现如下：

Java代码
  1. /**  
  2.      * 将腾讯微博的oauth持久化到文件中  
  3.      */  
  4.     private void persistTenOauth(){   
  5.         //加这一句的作用是防止  /data/data/package-name这个目录不存在   
  6.         String s = getFileStreamPath("aaa").getAbsolutePath();   
  7.         for(String ss : fileList()){   
  8.             System.out.println("ss==" + ss);   
  9.         }   
  10.         String x = "";   
  11.         try{   
  12.             x = s.substring(0,s.lastIndexOf("/"));   
  13.         }catch(Exception e){   
  14.             e.printStackTrace();   
  15.             x = "/data/data/yanbin.insertweibo";   
  16.         }   
  17.         //将文件存放在 /data/data/package-name目录下，当然你也可以存储在别的地方   
  18.         try {   
  19.             file = new File(x + "/oauth_ten.data");   
  20.             if(!file.exists()){   
  21.                 new File(x).mkdirs();   
  22.                 file.createNewFile();   
  23.             }   
  24.         } catch (Exception e) {   
  25.             e.printStackTrace();   
  26.         }   
  27.            
  28.     }  

       至此，我们已经成功的获取到了访问腾讯微博必须的令牌，接下来我们就可以使用这个令牌操纵api了。 

       人人网授权：

       人人网并没有实现发心情的功能，只是简单的获取了它的token。

       实现的代码如下：

Java代码
  1. if(!isOauthRenren()){   
  2.         renren = new Renren(API_KEY, SECRET_KEY, APP_ID, this);   
  3.         renren.authorize(this, null, new MyRenrenListener(), RENREN_REQUEST_CODE);   
  4. }else{   
  5.         Toast.makeText(getApplicationContext(), "该用户已经授权", Toast.LENGTH_SHORT).show();   
  6. }

       isOauthRenren用来判断用户是否对本客户端进行了授权。MyRenrenListener类会在用户在输入框中输入用户名和密码后回调。它们的具体实现如下：

       isOauthRenren()方法：

Java代码
  1. /**  
  2.      * renren 判断用户是否已经授权  
  3.      * @return  
  4.      */  
  5.     private boolean isOauthRenren(){   
  6.         boolean b = false;   
  7.         String token = getSharedPreferences("oauth_renren", Context.MODE_PRIVATE).getString("access_token", "");   
  8.         if(!"".equals(token)){   
  9.             b = true;   
  10.         }   
  11.         return b;   
  12.     }  

       MyRenrenListener类的实现：

Java代码
  1.  /**  
  2.      * 人人请求用户授权返回界面  
  3.      * @author yanbin  
  4.      *  
  5.      */  
  6.     private class MyRenrenListener implements RenrenAuthListener{   
  7.   
  8.         @Override  
  9.         public void onComplete(Bundle values) {   
  10.             //服务器端返回的数据   
  11. //          {   
  12. //          "access_token": "10000|5.a6b7dbd428f731035f771b8d15063f61.86400.1292922000-222209506",   
  13. //          "expires_in": 87063,   
  14. //          "refresh_token": "10000|0.385d55f8615fdfd9edb7c4b5ebdc3e39-222209506",   
  15. //          "scope": "read_user_album read_user_feed"   
  16. //          }   
  17.             Bundle bundle = values;   
  18.             String access_token = bundle.getString("access_token");   
  19.             int expires_in = bundle.getInt("expires_in");   
  20.             String refresh_token = bundle.getString("refresh_token");   
  21.             String scope = bundle.getString("scope");   
  22.             System.out.println("验证服务器端返回的数据-->" + "access_token-->" + access_token   
  23.                     + ",expires_in-->" + expires_in   
  24.                     + ",refresh_token-->" + refresh_token   
  25.                     + ",scope-->" + scope);   
  26.             SharedPreferences sp = getSharedPreferences("oauth_renren", Context.MODE_PRIVATE);   
  27.             sp.edit().putString("access_token", access_token).commit();   
  28.             Toast.makeText(getApplicationContext(), "用户授权成功", Toast.LENGTH_SHORT).show();   
  29.             //结果：   
  30.             //验证服务器端返回的数据-->access_token-->206681|6.725b8c8b3457a7d2953868d63aaf4486.2592000.1346828400-473945629   
  31.             //,expires_in-->0,refresh_token-->null,   
  32.             //scope-->publish_feed create_album photo_upload read_user_album status_update   
  33.         }   
  34.   
  35.         @Override  
  36.         public void onRenrenAuthError(RenrenAuthError renrenAuthError) {   
  37.             Toast.makeText(getApplicationContext(), "异常", Toast.LENGTH_SHORT).show();   
  38.         }   
  39.   
  40.         @Override  
  41.         public void onCancelLogin() {   
  42.             //未作处理   
  43.         }   
  44.   
  45.         @Override  
  46.         public void onCancelAuth(Bundle values) {   
  47.             //未作处理   
  48.         }   
  49.            
  50.     }  

       至此，我们也成功的获取到了访问人人网api的token，接下来就是对api的操作了。下面是一些相关的类（TestActivity.java）和AndroidManifest.xml文件。

       TestActivity.java：

Java代码
  1. package yanbin.insertWeibo;   
  2.   
  3. import java.net.InetAddress;   
  4. import java.net.NetworkInterface;   
  5. import java.net.SocketException;   
  6. import java.util.Enumeration;   
  7.   
  8.   
  9. import com.tencent.weibo.api.TAPI;   
  10. import com.tencent.weibo.constants.OAuthConstants;   
  11. import com.tencent.weibo.oauthv2.OAuthV2;   
  12. import com.weibo.net.Utility;   
  13. import com.weibo.net.Weibo;   
  14. import com.weibo.net.WeiboException;   
  15. import com.weibo.net.WeiboParameters;   
  16.   
  17. import android.app.Activity;   
  18. import android.os.Bundle;   
  19. import android.view.View;   
  20. import android.widget.Button;   
  21. import android.widget.EditText;   
  22. import android.widget.Toast;   
  23.   
  24. /**  
  25.  * 腾讯微博，新浪微博   简单的发送一条微博，可以进你自己的微博查看是否发送成功  
  26.  * @author yanbin  
  27.  */  
  28. public class TestActivity extends Activity {   
  29.     Button btnSend ;   
  30.     EditText et;   
  31.     String accessToken;   
  32.     OAuthV2 oAuthV2,oAuthV2_2;   
  33.     int flag ;//flag用来标记是来自新浪，腾讯微博还是人人   
  34.     @Override  
  35.     protected void onCreate(Bundle savedInstanceState) {   
  36.         super.onCreate(savedInstanceState);   
  37.         setContentView(R.layout.send_weibo);   
  38.         accessToken = getIntent().getStringExtra("accessToken");   
  39.         flag = getIntent().getIntExtra("flag", -1);   
  40.         oAuthV2 =  (OAuthV2) getIntent().getSerializableExtra("oauth");   
  41.         btnSend = (Button) findViewById(R.id.btnSend);   
  42.         et = (EditText) findViewById(R.id.et);   
  43.     }   
  44.        
  45.        
  46.     public void click(View view){   
  47.         int id = view.getId();   
  48.         switch (id) {   
  49.         case R.id.btnSend:   
  50.             switch (flag) {   
  51.             case MyContent.SINA:   
  52.                 Weibo weibo = Weibo.getInstance();   
  53.                 WeiboParameters parameters = new WeiboParameters();   
  54.                 parameters.add("access_token", accessToken);   
  55.                 parameters.add("status", et.getText().toString());   
  56.                 //发送一条微博 url https://api.weibo.com/2/statuses/update.json   
  57.                 try {   
  58.                     String flag = weibo.request(this, Weibo.SERVER + "statuses/update.json", parameters, Utility.HTTPMETHOD_POST, weibo.getAccessToken());   
  59.                     System.out.println("flag==" + flag);   
  60.                     Toast.makeText(this, "发送微博成功", 1).show();   
  61.                 } catch (WeiboException e) {   
  62.                     e.printStackTrace();   
  63.                     Toast.makeText(this, "发送微博失败", 1).show();   
  64.                 }   
  65.                 finish();   
  66.                 break;   
  67.             case MyContent.TENCENT:   
  68.                 TAPI tapi = new TAPI(OAuthConstants.OAUTH_VERSION_2_A);   
  69.                  try {   
  70.                      String response=tapi.add(oAuthV2, "json", et.getText().toString(), getHostIp());   
  71.                      System.out.println("response==" + response);   
  72.                      tapi.shutdownConnection();   
  73.                      System.out.println("发送微博成功");   
  74.                      Toast.makeText(this, "发送微博成功", 1).show();   
  75.                  } catch (Exception e) {   
  76.                      e.printStackTrace();   
  77.                      Toast.makeText(this, "发送微博失败", 1).show();   
  78.                  }   
  79.                  finish();   
  80.                  break;   
  81.             }   
  82.             break;   
  83.         }   
  84.     }   
  85.      /**  
  86.      * 获取用户ip  
  87.      * @return  
  88.      */  
  89.     public static String getHostIp() {     
  90.         try {   
  91.             for (Enumeration<NetworkInterface> en = NetworkInterface   
  92.                     .getNetworkInterfaces(); en.hasMoreElements();) {   
  93.                 NetworkInterface intf = en.nextElement();   
  94.                 for (Enumeration<InetAddress> ipAddr = intf.getInetAddresses(); ipAddr   
  95.                         .hasMoreElements();) {   
  96.                     InetAddress inetAddress = ipAddr.nextElement();   
  97.                     if (!inetAddress.isLoopbackAddress()) {                        
  98.                         return inetAddress.getHostAddress();   
  99.                     }   
  100.                 }   
  101.             }   
  102.         } catch (SocketException ex) {   
  103.         } catch (Exception e) {   
  104.         }   
  105.         return null;   
  106.     }   
  107. }  

       AndroidManifest.xml：

XML/HTML代码
  1. <?xml version="1.0" encoding="utf-8"?>  
  2. <manifest xmlns:android="http://schemas.android.com/apk/res/android"  
  3.     package="yanbin.insertWeibo"  
  4.     android:versionCode="1"  
  5.     android:versionName="1.0" >  
  6.   
  7.     <uses-sdk android:minSdkVersion="7" />  
  8.   
  9.     <application  
  10.         android:icon="@drawable/ic_launcher"  
  11.         android:label="@string/app_name" >  
  12.         <activity  
  13.             android:name=".InsertWeiboActivity"  
  14.             android:label="@string/app_name" >  
  15.             <intent-filter>  
  16.                 <action android:name="android.intent.action.MAIN" />  
  17.   
  18.                 <category android:name="android.intent.category.LAUNCHER" />  
  19.             </intent-filter>  
  20.         </activity>  
  21.         <activity android:name=".TestActivity"></activity>  
  22.         <!-- OAuth Version 2. 使用  WebView 辅助进行ImplicitGrant方式授权必须 -->  
  23.         <activity  
  24.             android:name="com.tencent.weibo.webview.OAuthV2AuthorizeWebView"  
  25.             android:label="@string/app_name" >  
  26.         </activity>  
  27.     </application>  
  28.     <uses-permission android:name="android.permission.INTERNET"></uses-permission>      
  29.     <uses-permission android:name="android.permission.ACCESS_WIFI_STATE"></uses-permission>    
  30.     <uses-permission android:name="android.permission.WRITE_APN_SETTINGS"></uses-permission>  
  31.     <uses-permission android:name="android.permission.CHANGE_WIFI_STATE"></uses-permission>  
  32.     <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"></uses-permission>  
  33.     <!-- 在SDCard中创建与删除文件权限 -->  
  34.     <uses-permission android:name="android.permission.MOUNT_UNMOUNT_FILESYSTEMS"/>  
  35.     <!-- 往SDCard写入数据权限 -->  
  36.     <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>  
  37. </manifest>  

       接入社交平台本就是一个比较简单的功能，想跟大家说详细些，所以文章篇幅有点长，望耐心看完。


联系
我们