android客户端接入新浪、腾讯微博以及人人网

标签： android 客户端 新浪 | 发表时间：2013-05-27 19:31 | 作者：qingniaofy
出处：http://blog.csdn.net

本文原创 http://blog.csdn.net/yanbin1079415046，转载请注明出处。

  从事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作为验证与授权协议。

  2012.10月编辑：

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

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

三：关于OAuth2.0

   本人比较懒，就不把概念贴在这里了。自己百度去吧，百度百科中有这样的一句概括：OAuth 2.0关注客户端开发者的简易性，同时为Web应用，桌面应用和手机，和起居室设备提供专门的认证流程。这里我们稍微说一下OAuth2.0的认证流程。文章请看这里： http://blog.unvs.cn/archives/oauth-qq2.0-developer.html。首先感谢这位哥们，然后不想点开链接的同学就直接看下面的吧。

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

1、得到授权码code
2、获取access token
3、通过access token,获取OpenID
4、通过access token及OpenID调用API,获取用户授权信息
上面是流程的大概四个步骤，在下面的流程示意图中会得到体现，这是我制作的一个幻灯片的流程图（文章最后会附上制作的OAuth幻灯片分享给大家），这里就直接截图下来进行讲解：
图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文件夹拷贝到你自己的工程中覆盖原有的文件即可。

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

  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;  

 

  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方法如下，它的作用是判断用户是否已经对我们的应用进行了授权。

  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类型的参数，值就是我们在之前提到过得那个授权回调页的地址。接着新浪微博将弹出一个授权页面的对话框，供用户输入用户名和密码（此处就不截图，自己跑demo看吧）。在用户输入用户名和密码之后，它将被我们的OauthDialogListener类监听到，它的实现如下：

  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这个页面，所以要在清单文件中声明。

  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()方法：

  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()方法：

  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对象存起来，这里使用对象流的方式，具体实现如下:

  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。

实现的代码如下：

  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()方法：

  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.     }  
  13.    

MyRenrenListener类的实现：

  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： 

  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：

  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>  

六：结束语

    接入社交平台本就是一个比价简单的功能，但是由于本人能力有限，组织语言能力也有限，所以整出了这么长一个篇幅，而且感觉还讲的不是很清楚，大部分篇幅都在贴代码。第一次发文章，感觉吧，特累。不说了，有需要的朋友直接去下demo自己捉摸捉摸吧。

DEMO下载地址： http://download.csdn.net/detail/yanbin1079415046/4497659

作者：qingniaofy 发表于2013-5-27 19:31:36 原文链接
阅读：0 评论：0 查看评论

相关 [android 客户端 新浪] 推荐：

新浪微博Android客户端SSO授权认证缺陷

- - BlogJava-首页技术区
转载请注明出处:  http://www.blogjava.net/zh-weir/archive/2013/09/08/403829.html. 新浪微博Android客户端SSO授权认证缺陷. 从最近几年开始，做平台的公司都流行起Open API. 这是一个非常好的理念，也受到广大开发者的欢迎.

android客户端接入新浪、腾讯微博以及人人网

- - CSDN博客移动开发推荐文章
本文原创 http://blog.csdn.net/yanbin1079415046，转载请注明出处.   从事android工作也有段时间了，碍于肚子里料不多，一直也没写过什么东西. 最近刚好项目中要接入新浪微博，就顺便研究了一下android客户端接入腾讯微博和人人网. 由于是第一次写东西，加上本人小菜鸟一个，请高手勿喷，觉得文章没用的飘过，当然啦，觉得还有点用的就看看吧.

优秀的Android Twitter客户端

- 馒头 - Solidot
Irene Janes 写道 "无论用任何标准衡量，社交网络正日益成为生活的一部分. Twitter是最流行的社交网络服务之一. 12个月前，它每天约发送6500万条消息；今天，这一数字已经上升到每天超过2亿条，相当于2亿注册用户每人每天发送一条. Twitter从根本上改变了许多人的交流方式.

新浪微博 Linux 客户端 Weico 正式发布

- openboy - Wow! Ubuntu
Weico 是由国内知名设计团队 eico Design 开发的新浪微博客户端 ，之前一直流行于 iPhone 平台，现在他们正式发布了桌面客户端，采用 Adobe AIR 技术构建，跨平台，支持 MacOSX ，Win 及 Linux 系统. Weico 采用了迷你风格，大小仅比输入法提示条大一点点，可以悬浮在屏幕的角落，同时具备很好的 UI 体验.

新浪微博 WP 客户端开发经验分享

- - 微博之博
新浪微博也是国内比较早的登录 Windows Phone 平台的应用，以下是新浪 Windows Phone 平台 微博产品负责人 彭姗对 Windows Phone 开发经验的分享，以及对新浪微博 WP 客户端融入 Metro UI 所做的一系列创新式改变和在 Marketplace 通过审核经验的介绍.

谈Android手机客户端的适配测试

- - Taobao QA Team
一、           Android 客户端为什么要进行适配测试. 在正式开始android客户端的适配测试点整理之前，先给大家看几个数据. 下面是随机抽取某个android客户端在2月份的用户使用情况. 【Android不同系统版本下的分布情况】. 【客户端在不同手机分辨率下被使用的分布情况】.

Android客户端代码保护技术-完整性校验

- - 移动开发 - ITeye博客
  由于Android系统固有的缺陷、Android应用分发渠道管理机制等问题，导致Android客户端程序很容易被反编译篡改/二次打包，经任意签名后可在各个渠道或论坛中发布，这不仅损害了开发者的知识产权，更可能威胁到用户的敏感信息及财产安全，因此客户端程序自身的安全性尤为重要，本文以客户端完整校验为主题，提供几种Android客户端完整性校验的实现思路，供广大开发者参考.

朋游风景网推出iOS、Android 客户端，瞄准智能旅游市场

- Draven - 36氪
以前外出旅行，跟团的话，总是觉着被牵着走特别不爽；自己玩又不知道按照什么路线，又不知道各个景点背后有什么故事. 这时候就会想，有没有一个手机App，去一个景点时，它可以为你自动规划参观路线，同时还为你介绍每个景点的相关信息呢. 广州创业公司朋游风景网 就打算解决这个问题. 朋游风景于8月1日正式上线了其网站，并同期发布了iOS 应用、Android 应用.

光学识别信用卡阅读器Card.io终于发布Android版客户端

- Ying-An - 36氪
移动支付公司Card.io今天终于面向Android开发者推出了光学字符识别信用卡阅读器，结束了该应用一直没有Android客户端的历史. Card.io是一家为智能手机提供基于软件的信用卡支付解决方案的公司，该公司的技术可以让用户拿着智能手机对信用卡拍照，然后进行光学识别，进而完成支付. 一般情况下，用户在智能手机上完成信用卡支付需要很多步骤，并且在手动输入卡号时经常出错，甚至因此放弃手机支付.

腾讯应用中心Android客户端上线 设安全认证

- Tony - cnBeta.COM
Android腾讯应用中心客户端昨日全新上线，其前身是“QQ手机软件管理”. 腾讯应用中心Android客户端全新的UI和架构，显示出腾讯应用中心的社区化和开放平台理念，同时腾讯应用中心每款应用都经专业的QQ手机管家认证，用户下载更安心.