您所在的位置： 首页 > 最新热文 > 计算机探索

    安卓的tumblr登录问题和QUOT; JumblrException：未授权＆QUOT;问题、tumblr、JumblrException、QUOT

    2023-09-04 07:48:41 作者：迈着猫步奔夕阳

    为什么下面code给我这样类型的异常 com.tumblr.jumblr.exceptions.JumblrException：未授权

    我看到了this问题，但我不能够解决这个问题... plz帮助我

     公共类MainActivity扩展活动实现OnClickListener {

    私有静态最后字符串变量=TumblrDemo;
    私有静态最后弦乐preFERENCE_NAME =tumblr;

    公共静态最后弦乐REQUEST_TOKEN_URL =htt​​ps://www.tumblr.com/oauth/request_token;
    公共静态最后弦乐ACCESS_TOKEN_URL =htt​​ps://www.tumblr.com/oauth/access_token;
    公共静态最后弦乐AUTH_URL =htt​​ps://www.tumblr.com/oauth/authorize;
    //公共静态最后弦乐CALLBACK_URL =
    //tumblrdemo：//tumblrdemo.com/ok;

    公共静态最后弦乐OAUTH_CALLBACK_SCHEME =oauthflow-tumblr;
    公共静态最后弦乐OAUTH_CALLBACK_HOST =回调;
    公共静态最后弦乐CALLBACK_URL = OAUTH_CALLBACK_SCHEME +：//
            + OAUTH_CALLBACK_HOST;

    私人TransparentProgressDialog progressDialog;
    私人按钮loginTumblrBtn;
    私人共享preferences preferences;
    私人CommonsHttpOAuthConsumer消费;
    私人CommonsHttpOAuthProvider供应商;
    私人字符串令牌，token_secret，oauth_verifier;

    @覆盖
    保护无效的onCreate（包savedInstanceState）{
        super.onCreate（savedInstanceState）;
        的setContentView（R.layout.activity_main）;

        消费=新CommonsHttpOAuthConsumer（Constant.CONSUMER_KEY，
                Constant.CONSUMER_SECRET）;

        供应商=新CommonsHttpOAuthProvider（REQUEST_TOKEN_URL，
                ACCESS_TOKEN_URL，AUTH_URL）;

        preferences = getShared preferences（preFERENCE_NAME，
                Context.MODE_PRIVATE）;
        loginTumblrBtn =（按钮）findViewById（R.id.login_tumblr）;

        。URI URI = this.getIntent（）的getData（）;

        如果（URI = NULL和放大器;！＆安培; uri.getScheme（）等于（OAUTH_CALLBACK_SCHEME））{
            loginTumblrBtn.setText（的getString（R.string.logout_tumblr））;
            尝试 {
                oauth_verifier = uri.getQueryParameter（OAuth.OAUTH_VERIFIER）;

                Log.d（TAG，uri.toString（））;
                // provider.retrieveAccessToken（消费者，oauth_verifier）;

                //令牌= consumer.getToken（）;
                // token_secret = consumer.getTokenSecret（）;

                令牌= uri.getQueryParameter（oauth_token）;
                token_secret = uri.getQueryParameter（oauth_verifier）;
                consumer.setTokenWithSecret（令牌，token_secret）;
                共享preferences.Editor编辑器= preferences.edit（）;
                editor.putString（Constant.TOKEN，令牌）;
                editor.putString（Constant.TOKEN_SECRET，token_secret）;
                editor.commit（）;

                getUserDetails（）;
            }赶上（例外五）{
                e.printStackTrace（）;
            }
        } 其他 {

            loginTumblrBtn.setText（的getString（R.string.login_tumblr））;
        }
        loginTumblrBtn.setOnClickListener（本）;
    }

    @覆盖
    公共无效的onClick（视图v）{

        如果（v.getId（）== R.id.login_tumblr）{

            如果（isTumblrConnected（））{

                共享preferences.Editor编辑器= preferences.edit（）;
                editor.putString（Constant.TOKEN，NULL）;
                editor.putString（Constant.TOKEN_SECRET，NULL）;
                editor.commit（）;
                loginTumblrBtn.setText（的getString（R.string.login_tumblr））;
            } 其他 {
                新AsyncTaskClass（）执行（）;
            }
        }

    }

    私人布尔isTumblrConnected（）{
        返回preferences.getString（Constant.TOKEN，NULL）！= NULL;
    }

    私有类AsyncTaskClass扩展的AsyncTask＆LT;虚空，虚空，虚空＆GT; {

        @覆盖
        保护无效doInBackground（虚空...... PARAMS）{
            尝试 {
                字符串authUrl = provider.retrieveRequestToken（消费者，
                        CALLBACK_URL）;

                startActivity（新的意向书（android.intent.action.VIEW
                        Uri.parse（authUrl）））;

            }赶上（例外五）{
                e.printStackTrace（）;
            }
            返回null;
        }

        @覆盖
        在preExecute保护无效（）{

            super.on preExecute（）;
            progressDialog =新TransparentProgressDialog（MainActivity.this，
                    R.drawable.loading）;
            progressDialog.show（）;

        }

        @覆盖
        保护无效onPostExecute（无效的结果）{

            super.onPostExecute（结果）;
            如果（progressDialog = NULL和放大器;！＆安培; progressDialog.isShowing（））
                progressDialog.dismiss（）;

        }

    }

    @覆盖
    保护无效onResume（）{
        // TODO自动生成方法存根
        super.onResume（）;
        如果（isTumblrConnected（））{
            令牌= preferences.getString（Constant.TOKEN，NULL）;
            token_secret = preferences.getString（Constant.TOKEN_SECRET，NULL）;
            loginTumblrBtn.setText（的getString（R.string.logout_tumblr））;
            getUserDetails（）;
        } 其他 {
            loginTumblrBtn.setText（的getString（R.string.login_tumblr））;
        }
    }

    私人无效getUserDetails（）{
        新主题（新的Runnable（）{

            @覆盖
            公共无效的run（）{
                尝试 {

                    JumblrClient客户端=新JumblrClient（
                            Constant.CONSUMER_KEY，Constant.CONSUMER_SECRET）;
                    client.setToken（令牌，token_secret）;

                    //写用户名
                    用户USER = client.user（）;

                    的System.out.println（user.getName（））;
                }赶上（例外五）{
                    e.printStackTrace（）;
                }
            }
        }）。开始（）;
    }
}

    解决方案

    雅终于得到解决方案的工作太多了，我误解之间的访问令牌和请求令牌。

    这是工作的解决方案上面issue.Hope它为你工作。

     公共类MainActivity扩展活动实现OnClickListener {

    私人按钮loginTumblrBtn;
    私人CommonsHttpOAuthConsumer消费;
    私人CommonsHttpOAuthProvider供应商;
    私人共享preferences preferences;
    私人开放的URI;
    私人ProgressDialog progressDialog;

    @覆盖
    保护无效的onCreate（包savedInstanceState）{
        super.onCreate（savedInstanceState）;
        的setContentView（R.layout.activity_main）;

        preferences = getShared preferences（tumblr，Context.MODE_PRIVATE）;

        loginTumblrBtn =（按钮）findViewById（R.id.login_tumblr）;
        loginTumblrBtn.setOnClickListener（本）;

        消费=新CommonsHttpOAuthConsumer（Constant.CONSUMER_KEY，
                Constant.CONSUMER_SECRET）;

        供应商=新CommonsHttpOAuthProvider（Constant.REQUEST_TOKEN_URL，
                Constant.ACCESS_TOKEN_URL，Constant.AUTH_URL）;

        URI = this.getIntent（）的getData（）。

        如果（URI！= NULL
                ＆功放;＆安培; uri.getScheme（）。等于（Constant.OAUTH_CALLBACK_SCHEME））{

            loginTumblrBtn.setText（的getString（R.string.logout_tumblr））;
            线程线程=新主题（新的Runnable（）{

                @覆盖
                公共无效的run（）{

                    尝试 {
                        consumer.setTokenWithSecret（
                                preferences.getString（requestToken，），
                                preferences.getString（requestSecret，））;

                        provider.setOAuth10a（真正的）;
                        provider.retrieveAccessToken（消费者，
                                uri.getQueryParameter（OAuth.OAUTH_VERIFIER））;

                        consumer.setTokenWithSecret（consumer.getToken（），
                                consumer.getTokenSecret（））;

                        共享preferences.Editor编辑器= preferences.edit（）;
                        editor.putString（令牌，consumer.getToken（））;
                        editor.putString（token_secret
                                consumer.getTokenSecret（））;
                        editor.commit（）;
                    }赶上（例外五）{
                        e.printStackTrace（）;
                    }
                }
            }）;
            thread.start（）;
            尝试 {
                的Thread.join（）;
            }赶上（InterruptedException异常E）{
                e.printStackTrace（）;
            }
        } 其他 {
            loginTumblrBtn.setText（的getString（R.string.login_tumblr））;
        }

    }

    @覆盖
    公共无效的onClick（视图v）{

        开关（v.getId（））{
        案例R.id.login_tumblr：
            如果（preferences.getString（令牌，NULL）！= NULL）{

                loginTumblrBtn.setText（的getString（R.string.login_tumblr））;
                共享preferences.Editor编辑器= preferences.edit（）;
                editor.putString（令牌，NULL）;
                editor.putString（token_secret，NULL）;
                editor.commit（）;
            } 其他 {
                progressDialog = ProgressDialog.show（这一点，加载，
                        请稍候...）;
                新主题（新的Runnable（）{

                    @覆盖
                    公共无效的run（）{
                        尝试 {
                            字符串authUrl = provider.retrieveRequestToken（
                                    消费，Constant.CALLBACK_URL）;
                            共享preferences.Editor编辑器= preferences
                                    。编辑（）;
                            editor.putString（requestToken
                                    consumer.getToken（））;
                            editor.putString（requestSecret
                                    consumer.getTokenSecret（））;
                            editor.commit（）;
                            startActivity（新意图（
                                    android.intent.action.VIEW，乌里
                                            .parse（authUrl）））;
                        }赶上（例外五）{
                            e.printStackTrace（）;
                        }

                    }
                }）。开始（）;
            }
            打破;
        }

    }

    @覆盖
    保护无效onResume（）{
        // TODO自动生成方法存根
        super.onResume（）;
        如果（preferences.getString（令牌，NULL）！= NULL）{
            loginTumblrBtn.setText（的getString（R.string.logout_tumblr））;
        } 其他 {
            loginTumblrBtn.setText（的getString（R.string.login_tumblr））;
        }
    }

    @覆盖
    保护无效的onPause（）{
        // TODO自动生成方法存根
        super.onPause（）;

        如果（progressDialog =空＆安培;！＆安培; progressDialog.isShowing（））{
            progressDialog.dismiss（）;
        }
    }
}

    ，并把这个意图过滤器code里面清单>应用程序>活动（其中回调完成）

     ＆LT;意向滤光器＆gt;
            ＆lt;作用机器人：名称=android.intent.action.VIEW/＆GT;

            ＆LT;类机器人：名称=android.intent.category.DEFAULT/＆GT;
            ＆LT;类机器人：名称=android.intent.category.BROWSABLE/＆GT;

            ＆lt;数据
                机器人：主机=回调
                机器人：计划=oauthflow-tumblr/＆GT;
        ＆所述; /意图滤光器＆gt;
    安卓手机怎么安装tumblr,汤不热注册教程 图解

    在tumblr 图片共享 

     公共无效shareImageOnTumblr（最终文件imgFile，最后弦乐标题，
            最终的处理程序处理）{
        新主题（新的Runnable（）{

            @覆盖
            公共无效的run（）{

                尝试 {
                    PhotoPost photoPost = client.newPost（client.user（）
                            。.getBlogs（）得到（0）.getName（），PhotoPost.class）;
                    如果（！caption.isEmpty（））
                        photoPost.setCaption（字幕）;

                    photoPost.setPhoto（新照片（imgFile））;
                    photoPost.save（）;
                    束束=新包（）;
                    消息消息=新的Message（）;
                    bundle.putInt（法，
                            UploadActivity.SHARED_PHOTO_SUCCESSFULLY）;
                    message.setData（包）;
                    handler.sendMessage（消息）;
                }赶上（例外五）{
                    e.printStackTrace（）;
                }
            }
        }）。开始（）;

    }

    在tumblr 视频分享 

     公共无效shareVideoOnTumblr（最终文件videoFile，最后弦乐标题，
        最终的处理程序处理）{

    新主题（新的Runnable（）{

        @覆盖
        公共无效的run（）{

            尝试 {
                VideoPost videoPost = client.newPost（client.user（）
                        。.getBlogs（）得到（0）.getName（），VideoPost.class）;

                如果（！caption.toString（）。的isEmpty（））
                    videoPost.setCaption（caption.toString（））;
                videoPost.setData（videoFile）;
                videoPost.save（）;
                束束=新包（）;
                消息消息=新的Message（）;
                bundle.putInt（法，
                        UploadActivity.SHARED_VIDEO_SUCCESSFULLY）;
                message.setData（包）;
                handler.sendMessage（消息）;
            }赶上（例外五）{
                e.printStackTrace（）;
            }
        }
    }）。开始（）;
}

    Why following code giving me such type of exception com.tumblr.jumblr.exceptions.JumblrException: Not Authorized

    I saw this question , but i am not able to resolved this issue...plz help me

    public class MainActivity extends Activity implements OnClickListener {

    private static final String TAG = "TumblrDemo";
    private static final String PREFERENCE_NAME = "tumblr";

    public static final String REQUEST_TOKEN_URL = "https://www.tumblr.com/oauth/request_token";
    public static final String ACCESS_TOKEN_URL = "https://www.tumblr.com/oauth/access_token";
    public static final String AUTH_URL = "https://www.tumblr.com/oauth/authorize";
    // public static final String CALLBACK_URL =
    // "tumblrdemo://tumblrdemo.com/ok";

    public static final String OAUTH_CALLBACK_SCHEME = "oauthflow-tumblr";
    public static final String OAUTH_CALLBACK_HOST = "callback";
    public static final String CALLBACK_URL = OAUTH_CALLBACK_SCHEME + "://"
            + OAUTH_CALLBACK_HOST;

    private TransparentProgressDialog progressDialog;
    private Button loginTumblrBtn;
    private SharedPreferences preferences;
    private CommonsHttpOAuthConsumer consumer;
    private CommonsHttpOAuthProvider provider;
    private String token, token_secret, oauth_verifier;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        consumer = new CommonsHttpOAuthConsumer(Constant.CONSUMER_KEY,
                Constant.CONSUMER_SECRET);

        provider = new CommonsHttpOAuthProvider(REQUEST_TOKEN_URL,
                ACCESS_TOKEN_URL, AUTH_URL);

        preferences = getSharedPreferences(PREFERENCE_NAME,
                Context.MODE_PRIVATE);
        loginTumblrBtn = (Button) findViewById(R.id.login_tumblr);

        Uri uri = this.getIntent().getData();

        if (uri != null && uri.getScheme().equals(OAUTH_CALLBACK_SCHEME)) {
            loginTumblrBtn.setText(getString(R.string.logout_tumblr));
            try {
                oauth_verifier = uri.getQueryParameter(OAuth.OAUTH_VERIFIER);

                Log.d(TAG, uri.toString());
                // provider.retrieveAccessToken(consumer, oauth_verifier);

                // token = consumer.getToken();
                // token_secret = consumer.getTokenSecret();

                token = uri.getQueryParameter("oauth_token");
                token_secret = uri.getQueryParameter("oauth_verifier");
                consumer.setTokenWithSecret(token, token_secret);
                SharedPreferences.Editor editor = preferences.edit();
                editor.putString(Constant.TOKEN, token);
                editor.putString(Constant.TOKEN_SECRET, token_secret);
                editor.commit();

                getUserDetails();
            } catch (Exception e) {
                e.printStackTrace();
            }
        } else {

            loginTumblrBtn.setText(getString(R.string.login_tumblr));
        }
        loginTumblrBtn.setOnClickListener(this);
    }

    @Override
    public void onClick(View v) {

        if (v.getId() == R.id.login_tumblr) {

            if (isTumblrConnected()) {

                SharedPreferences.Editor editor = preferences.edit();
                editor.putString(Constant.TOKEN, null);
                editor.putString(Constant.TOKEN_SECRET, null);
                editor.commit();
                loginTumblrBtn.setText(getString(R.string.login_tumblr));
            } else {
                new AsyncTaskClass().execute();
            }
        }

    }

    private boolean isTumblrConnected() {
        return preferences.getString(Constant.TOKEN, null) != null;
    }

    private class AsyncTaskClass extends AsyncTask<Void, Void, Void> {

        @Override
        protected Void doInBackground(Void... params) {
            try {
                String authUrl = provider.retrieveRequestToken(consumer,
                        CALLBACK_URL);

                startActivity(new Intent("android.intent.action.VIEW",
                        Uri.parse(authUrl)));

            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }

        @Override
        protected void onPreExecute() {

            super.onPreExecute();
            progressDialog = new TransparentProgressDialog(MainActivity.this,
                    R.drawable.loading);
            progressDialog.show();

        }

        @Override
        protected void onPostExecute(Void result) {

            super.onPostExecute(result);
            if (progressDialog != null && progressDialog.isShowing())
                progressDialog.dismiss();

        }

    }

    @Override
    protected void onResume() {
        // TODO Auto-generated method stub
        super.onResume();
        if (isTumblrConnected()) {
            token = preferences.getString(Constant.TOKEN, null);
            token_secret = preferences.getString(Constant.TOKEN_SECRET, null);
            loginTumblrBtn.setText(getString(R.string.logout_tumblr));
            getUserDetails();
        } else {
            loginTumblrBtn.setText(getString(R.string.login_tumblr));
        }
    }

    private void getUserDetails() {
        new Thread(new Runnable() {

            @Override
            public void run() {
                try {

                    JumblrClient client = new JumblrClient(
                            Constant.CONSUMER_KEY, Constant.CONSUMER_SECRET);
                    client.setToken(token, token_secret);

                    // Write the user's name
                    User user = client.user();

                    System.out.println(user.getName());
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}

    解决方案

    Ya finally got solution after too much work, i misunderstood between access token and request token.

    Here it is working solution for above issue.Hope it works for you.

    public class MainActivity extends Activity implements OnClickListener {

    private Button loginTumblrBtn;
    private CommonsHttpOAuthConsumer consumer;
    private CommonsHttpOAuthProvider provider;
    private SharedPreferences preferences;
    private Uri uri;
    private ProgressDialog progressDialog;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        preferences = getSharedPreferences("tumblr", Context.MODE_PRIVATE);

        loginTumblrBtn = (Button) findViewById(R.id.login_tumblr);
        loginTumblrBtn.setOnClickListener(this);

        consumer = new CommonsHttpOAuthConsumer(Constant.CONSUMER_KEY,
                Constant.CONSUMER_SECRET);

        provider = new CommonsHttpOAuthProvider(Constant.REQUEST_TOKEN_URL,
                Constant.ACCESS_TOKEN_URL, Constant.AUTH_URL);

        uri = this.getIntent().getData();

        if (uri != null
                && uri.getScheme().equals(Constant.OAUTH_CALLBACK_SCHEME)) {

            loginTumblrBtn.setText(getString(R.string.logout_tumblr));
            Thread thread = new Thread(new Runnable() {

                @Override
                public void run() {

                    try {
                        consumer.setTokenWithSecret(
                                preferences.getString("requestToken", ""),
                                preferences.getString("requestSecret", ""));

                        provider.setOAuth10a(true);
                        provider.retrieveAccessToken(consumer,
                                uri.getQueryParameter(OAuth.OAUTH_VERIFIER));

                        consumer.setTokenWithSecret(consumer.getToken(),
                                consumer.getTokenSecret());

                        SharedPreferences.Editor editor = preferences.edit();
                        editor.putString("token", consumer.getToken());
                        editor.putString("token_secret",
                                consumer.getTokenSecret());
                        editor.commit();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            });
            thread.start();
            try {
                thread.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        } else {
            loginTumblrBtn.setText(getString(R.string.login_tumblr));
        }

    }

    @Override
    public void onClick(View v) {

        switch (v.getId()) {
        case R.id.login_tumblr:
            if (preferences.getString("token", null) != null) {

                loginTumblrBtn.setText(getString(R.string.login_tumblr));
                SharedPreferences.Editor editor = preferences.edit();
                editor.putString("token", null);
                editor.putString("token_secret", null);
                editor.commit();
            } else {
                progressDialog = ProgressDialog.show(this, "Loading",
                        "Please Wait...");
                new Thread(new Runnable() {

                    @Override
                    public void run() {
                        try {
                            String authUrl = provider.retrieveRequestToken(
                                    consumer, Constant.CALLBACK_URL);
                            SharedPreferences.Editor editor = preferences
                                    .edit();
                            editor.putString("requestToken",
                                    consumer.getToken());
                            editor.putString("requestSecret",
                                    consumer.getTokenSecret());
                            editor.commit();
                            startActivity(new Intent(
                                    "android.intent.action.VIEW", Uri
                                            .parse(authUrl)));
                        } catch (Exception e) {
                            e.printStackTrace();
                        }

                    }
                }).start();
            }
            break;
        }

    }

    @Override
    protected void onResume() {
        // TODO Auto-generated method stub
        super.onResume();
        if (preferences.getString("token", null) != null) {
            loginTumblrBtn.setText(getString(R.string.logout_tumblr));
        } else {
            loginTumblrBtn.setText(getString(R.string.login_tumblr));
        }
    }

    @Override
    protected void onPause() {
        // TODO Auto-generated method stub
        super.onPause();

        if (progressDialog != null && progressDialog.isShowing()) {
            progressDialog.dismiss();
        }
    }
}

    and put this intent-filter code inside manifest>application>activity (where callback is done)

     <intent-filter>
            <action android:name="android.intent.action.VIEW" />

            <category android:name="android.intent.category.DEFAULT" />
            <category android:name="android.intent.category.BROWSABLE" />

            <data
                android:host="callback"
                android:scheme="oauthflow-tumblr" />
        </intent-filter>

    Image sharing on TUMBLR

    public void shareImageOnTumblr(final File imgFile, final String caption,
            final Handler handler) {
        new Thread(new Runnable() {

            @Override
            public void run() {

                try {
                    PhotoPost photoPost = client.newPost(client.user()
                            .getBlogs().get(0).getName(), PhotoPost.class);
                    if (!caption.isEmpty())
                        photoPost.setCaption(caption);

                    photoPost.setPhoto(new Photo(imgFile));
                    photoPost.save();
                    Bundle bundle = new Bundle();
                    Message message = new Message();
                    bundle.putInt("method",
                            UploadActivity.SHARED_PHOTO_SUCCESSFULLY);
                    message.setData(bundle);
                    handler.sendMessage(message);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();

    }

    Video sharing on TUMBLR

    public void shareVideoOnTumblr(final File videoFile, final String caption,
        final Handler handler) {

    new Thread(new Runnable() {

        @Override
        public void run() {

            try {
                VideoPost videoPost = client.newPost(client.user()
                        .getBlogs().get(0).getName(), VideoPost.class);

                if (!caption.toString().isEmpty())
                    videoPost.setCaption(caption.toString());
                videoPost.setData(videoFile);
                videoPost.save();
                Bundle bundle = new Bundle();
                Message message = new Message();
                bundle.putInt("method",
                        UploadActivity.SHARED_VIDEO_SUCCESSFULLY);
                message.setData(bundle);
                handler.sendMessage(message);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }).start();
}

    上一篇：F＃/。NET空实例怪胎怪胎、实例、NET

    下一篇：检查两个列表有碰撞的元素？元素、两个、列表

    相关推荐
     
    猜您喜欢
    香港英国硕士艳尸门事变 残害之后与尸身拍艳照纪念

    香港英国硕士艳尸门事变 残害之后与尸身

    精彩图集
    精彩推荐
    图片推荐

    探秘家（tanmijia.com），深层探秘世界自然奇观未解之谜，揭秘宇宙空间、人类、生物未解之谜,世界传闻、奇闻异事ufo未解之谜。有效真实科学探索天下奇观猎奇世界。

    © 2016-2021 探秘家. All Rights Reserved 浙ICP备20029812号-3