在Android上发布twitter后退出应用程序？

我正在开发一个基本的安卓应用程序，在这个程序中，我在推特上的个人资料上发布了一个小文本字符串。 问题是，在twitter上发布后，我的应用程序退出。我在以前的应用程序中使用了相同的代码，但现在它不起作用了。请让我知道我犯了什么错误

下面是PrepareRequestTokenActivity.java的代码

/**
 * Prepares a OAuthConsumer and OAuthProvider 
 * 
 * OAuthConsumer is configured with the consumer key & consumer secret.
 * OAuthProvider is configured with the 3 OAuth endpoints.
 * 
 * Execute the OAuthRequestTokenTask to retrieve the request, and authorize the request.
 * 
 * After the request is authorized, a callback is made here.
 * 
 */
public class PrepareRequestTokenActivity extends Activity {

    public static boolean isTweetCompleted = false;
    public static int  checkvalue=0;
    final String TAG = getClass().getName();

    private OAuthConsumer consumer; 
    private OAuthProvider provider;
    private boolean _isProcessCompleted;



    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        requestWindowFeature(Window.FEATURE_NO_TITLE);
        setContentView(R.layout.twitter_dialog);
        checkvalue=this.getIntent().getIntExtra("check",0);
        @SuppressWarnings("unused")
        SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);
        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) {
        }
        new OAuthRequestTokenTask(this,consumer,provider).execute();
        _isProcessCompleted = true;
    }

    /**
     * Called when the OAuthRequestTokenTask finishes (user has authorized the request token).
     * The callback URL will be intercepted here.
     */
    @Override
    public void onNewIntent(Intent intent) {
        super.onNewIntent(intent);
        _isProcessCompleted = true;
        SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);
        final Uri uri = intent.getData();
        if (uri != null && uri.getScheme().equals(Constants.OAUTH_CALLBACK_SCHEME)) {
            new RetrieveAccessTokenTask(this,consumer,provider,prefs).execute(uri);
        }
    }

    @Override
    protected void onResume() {
        if(!_isProcessCompleted)
            finish();
        else 
            _isProcessCompleted = false;
        super.onResume();
    }

    public class RetrieveAccessTokenTask extends AsyncTask<Uri, Void, Void> {

        private Context context;
        private OAuthProvider provider;
        private OAuthConsumer consumer;
        private SharedPreferences prefs;


        public RetrieveAccessTokenTask(Context context, OAuthConsumer consumer,OAuthProvider provider, SharedPreferences prefs) {
            this.context = context;
            this.consumer = consumer;
            this.provider = provider;
            this.prefs=prefs;
        }


        /**
         * Retrieve the oauth_verifier, and store the oauth and oauth_token_secret 
         * for future API calls.
         */
        @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,WeddingRituals.class));            
                //------------------------------------------------------------------------
                executeAfterAccessTokenRetrieval(prefs);

            } catch (Exception e) {
            }

            **PrepareRequestTokenActivity.this.finish();**
            return null;
        }
    }   

    private void executeAfterAccessTokenRetrieval(SharedPreferences prefs) {
        String msg = getIntent().getExtras().getString("tweet_msg");
        try {
            TwitterUtils.sendTweet(prefs, msg);
            Message message = new Message();
            message.arg1 = 0;
            saveHandler.sendMessage(message);
        } catch (Exception e) {
        }
    }

    private Handler saveHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            if(msg.arg1 == 0){
                Toast.makeText(PrepareRequestTokenActivity.this, "Message posted successfully", Toast.LENGTH_LONG).show();
            }
        }
    };

}

/**
*准备OAuthConsumer和OAuthProvider
* 
*OAuthConsumer配置了使用者密钥和使用者机密。
*OAuthProvider配置了3个OAuth端点。
* 
*执行OAuthRequestTokenTask以检索请求，并对请求进行授权。
* 
*请求被授权后，将在此处进行回调。
* 
*/
公共类PrepareRequestTokenActivity扩展活动{
公共静态布尔值isTweetCompleted=false；
公共静态int checkvalue=0；
最后一个字符串标记=getClass（）.getName（）；
私人消费者；
私有OAuthProvider；
私有布尔值_i已完成处理；
@凌驾
创建时的公共void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
requestWindowFeature（窗口。功能\u无\u标题）；
setContentView（R.layout.twitter_对话框）；
checkvalue=this.getIntent（）.getIntExtra（“检查”，0）；
@抑制警告（“未使用”）
SharedPreferences=PreferenceManager.getDefaultSharedPreferences（此）；
试一试{
this.consumer=newcommonHttpOAuthConsumer（Constants.consumer\u KEY，Constants.consumer\u SECRET）；
this.provider=新的CommonHttpOAuthProvider（常量.请求\ URL，常量.访问\ URL，常量.授权\ URL）；
}捕获（例外e）{
}
新的OAuthRequestTokenTask（this、consumer、provider）.execute（）；
_isProcessCompleted=true；
}
/**
*在OAuthRequestTokenTask完成时调用（用户已授权请求令牌）。
*将在此处拦截回调URL。
*/
@凌驾
公共帐篷（意向）{
super.onNewIntent（意向）；
_isProcessCompleted=true；
SharedPreferences=PreferenceManager.getDefaultSharedPreferences（此）；
最终Uri=intent.getData（）；
if（uri！=null&&uri.getScheme（）.equals（Constants.OAUTH\u CALLBACK\u SCHEME））{
新的RetrieveAccessTokenTask（this、consumer、provider、prefs）.execute（uri）；
}
}
@凌驾
受保护的void onResume（）{
如果（！\u isProcessCompleted）
完成（）；
其他的
_isProcessCompleted=false；
super.onResume（）；
}
公共类RetrieveAccessTokenTask扩展了AsyncTask{
私人语境；
私有OAuthProvider；
私人消费者；
私人共享参考优先权；
公共检索访问令牌任务（上下文上下文、OAuthConsumer使用者、OAuthProvider提供者、SharedReferences优先）{
this.context=上下文；
这个。消费者=消费者；
this.provider=提供者；
this.prefs=prefs；
}
/**
*检索oauth_验证器，并存储oauth和oauth_令牌_机密
*用于将来的API调用。
*/
@凌驾
受保护的Void doInBackground（Uri…参数）{
最终Uri=params[0]；
最终字符串oauth_验证器=uri.getQueryParameter（oauth.oauth_验证器）；
试一试{
provider.retrieveAccessToken（使用者、oauth_验证器）；
最终编辑器编辑=prefs.edit（）；
edit.putString（OAuth.OAuth_令牌，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（令牌，秘密）；
//------------------------------------------------------------------------
//新意图（上下文，婚礼仪式类）；
//------------------------------------------------------------------------
executeAfterAccessTokenRetrieval（prefs）；
}捕获（例外e）{
}
**PrepareRequestTokenActivity.this.finish（）**
返回null；
}
}   
私有void executeAfterAccessTokenRetrieval（SharedReferences优先）{
字符串msg=getIntent（）.getExtras（）.getString（“tweet_msg”）；
试一试{
sendTweet（prefs，msg）；
消息消息=新消息（）；
message.arg1=0；
saveHandler.sendMessage（消息）；
}捕获（例外e）{
}
}
私有处理程序saveHandler=新处理程序（）{
@凌驾
公共无效handleMessage（消息消息消息）{
如果（msg.arg1==0）{
Toast.makeText（PrepareRequestTokenActivity.this，“消息发布成功”，Toast.LENGTH_LONG.show（）；
}
}
};
}

我解决了这个问题，但这只是一个小问题。这次，我取消了对我从推特回来的代码的评论

context.startActivity(new Intent(context,WeddingRituals.class)); 

---

我解决了这个问题，但这只是一个例子。这次，我取消了回复活动的代码。