android - 在 Android 中没有 Activity 的情况下刷新服务中的 Azure 用户 token

Question

我正在使用 azure 移动服务创建一个 Android 应用程序。我有一个始终运行的服务(使用 startForeground())并监视一些用户 Activity 。该服务有时需要查询存储在 azure 云中的调用 API 的 azure 数据库，如下所示:

mClient.invokeApi("APIname", null, "GET", parameters);
//mClient is the MobileServiceClient instance

一开始，用户使用 LoginActivity 登录，一切正常。一段时间后(通常是 1 小时)，客户端的 token 过期了，我收到了如下异常:

IDX10223: Lifetime validation failed. The token is expired.

经过一番搜索，我找到了刷新 token 的解决方案: https://github.com/Microsoft/azure-docs/blob/master/includes/mobile-android-authenticate-app-refresh-token.md

如果 Activity 处于 Activity 状态，则代码将正常工作，并在过期时成功刷新 token 。但如果 Activity 被破坏了，它就不起作用了。所以我决定将 ApplicationContext 传递给客户端，这样:

mClient.setContext(activity.getApplicationContext());

但现在我收到 ClassCastException，因为客户端尝试将上下文转换为 Activity。以下是异常的有趣行:

     java.lang.ClassCastException: android.app.Application cannot be cast to android.app.Activity
                  at com.microsoft.windowsazure.mobileservices.authentication.LoginManager.showLoginUI(LoginManager.java:349)
                  at com.microsoft.windowsazure.mobileservices.authentication.LoginManager.authenticate(LoginManager.java:161)
                  at com.microsoft.windowsazure.mobileservices.MobileServiceClient.login(MobileServiceClient.java:371)
                  at com.microsoft.windowsazure.mobileservices.MobileServiceClient.login(MobileServiceClient.java:356)
                  at com.microsoft.windowsazure.mobileservices.MobileServiceClient.login(MobileServiceClient.java:309)

那么如何在没有 Activity 的情况下从服务刷新 token 呢？或者有其他方法可以让客户端始终经过身份验证吗？

编辑

我尝试在此处粘贴一些代码，希望能够更清楚地说明我使用身份验证 token 的方式。我有一个用于管理身份验证的 LoginManager。这是该类中一些有意义的代码:

 public boolean loadUserTokenCache(Context context)
{
    init(context); //update context

    SharedPreferences prefs = context.getSharedPreferences(SHARED_PREF_FILE, Context.MODE_PRIVATE);
    String userId = prefs.getString(USERID_PREF, null);
    if (userId == null)
        return false;
    String token = prefs.getString(LOGIN_TOKEN_PREF, null);
    if (token == null)
        return false;

    MobileServiceUser user = new MobileServiceUser(userId);
    user.setAuthenticationToken(token);
    mClient.setCurrentUser(user);

    return true;
}

过滤器是:

    private class RefreshTokenCacheFilter implements ServiceFilter {

    AtomicBoolean mAtomicAuthenticatingFlag = new AtomicBoolean();

    //--------------------http://stackoverflow.com/questions/7860384/android-how-to-runonuithread-in-other-class
    private final Handler handler;
    public RefreshTokenCacheFilter(Context context){
        handler = new Handler(context.getMainLooper());
    }
    private void runOnUiThread(Runnable r) {
        handler.post(r);
    }
    //--------------------

    @Override
    public ListenableFuture<ServiceFilterResponse> handleRequest(
            final ServiceFilterRequest request,
            final NextServiceFilterCallback nextServiceFilterCallback
    )
    {
        // In this example, if authentication is already in progress we block the request
        // until authentication is complete to avoid unnecessary authentications as
        // a result of HTTP status code 401.
        // If authentication was detected, add the token to the request.
        waitAndUpdateRequestToken(request);
        Log.d(Constants.TAG, logClassIdentifier+"REFRESH_TOKEN_CACHE_FILTER is Sending the request down the filter chain for 401 responses");
        Log.d(Constants.TAG, logClassIdentifier+mClient.getContext().toString());
        // Send the request down the filter chain
        // retrying up to 5 times on 401 response codes.
        ListenableFuture<ServiceFilterResponse> future = null;
        ServiceFilterResponse response = null;
        int responseCode = 401;
        for (int i = 0; (i < 5 ) && (responseCode == 401); i++)
        {
            future = nextServiceFilterCallback.onNext(request);
            try {
                response = future.get();
                responseCode = response.getStatus().code;
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                if (e.getCause().getClass() == MobileServiceException.class)
                {
                    MobileServiceException mEx = (MobileServiceException) e.getCause();
                    responseCode = mEx.getResponse().getStatus().code;
                    if (responseCode == 401)
                    {
                        // Two simultaneous requests from independent threads could get HTTP status 401.
                        // Protecting against that right here so multiple authentication requests are
                        // not setup to run on the UI thread.
                        // We only want to authenticate once. Requests should just wait and retry
                        // with the new token.
                        if (mAtomicAuthenticatingFlag.compareAndSet(false, true))
                        {
                            // Authenticate on UI thread

                            runOnUiThread(new Runnable() {
                                @Override
                                public void run() {
                                    // Force a token refresh during authentication.
                                    SharedPreferences pref = context.getSharedPreferences(Constants.SHARED_PREF_FILE, Context.MODE_PRIVATE);
                                    MobileServiceAuthenticationProvider provider = Utilities.getProviderFromName(pref.getString(Constants.LAST_PROVIDER_PREF, null));
                                    authenticate(context, provider, true);
                                }
                            });
                        }

                        // Wait for authentication to complete then update the token in the request.
                        waitAndUpdateRequestToken(request);
                        mAtomicAuthenticatingFlag.set(false);
                    }
                }
            }
        }
        return future;
    }
}

验证方法(我修改了一些小东西以正确显示对话框和主要 Activity ，但它的工作方式应该与 Microsoft 的原始代码相同):

  /**
     * Returns true if mClient is not null;
     * A standard sign-in requires the client to contact both the identity
     * provider and the back-end Azure service every time the app starts.
     * This method is inefficient, and you can have usage-related issues if
     * many customers try to start your app simultaneously. A better approach is
     * to cache the authorization token returned by the Azure service, and try
     * to use this first before using a provider-based sign-in.
     * This authenticate method uses a token cache.
     *
     * Authenticates with the desired login provider. Also caches the token.
     *
     * If a local token cache is detected, the token cache is used instead of an actual
     * login unless bRefresh is set to true forcing a refresh.
     *
     * @param bRefreshCache
     *            Indicates whether to force a token refresh.
     */
    public boolean authenticate(final Context context, MobileServiceAuthenticationProvider provider, final boolean bRefreshCache) {
        if (mClient== null)
            return false;
        final ProgressDialog pd = null;//Utilities.createAndShowProgressDialog(context, "Logging in", "Log in");

        bAuthenticating = true;

        // First try to load a token cache if one exists.
        if (!bRefreshCache && loadUserTokenCache(context)) {
            Log.d(Constants.TAG, logClassIdentifier+"User cached token loaded successfully");

            // Other threads may be blocked waiting to be notified when
            // authentication is complete.
            synchronized(mAuthenticationLock)
            {
                bAuthenticating = false;
                mAuthenticationLock.notifyAll();
            }

            QueryManager.getUser(context, mClient, mClient.getCurrentUser().getUserId(), pd);
            return true;
        }else{
            Log.d(Constants.TAG, logClassIdentifier+"No cached token found or bRefreshCache");
        }

        // If we failed to load a token cache, login and create a token cache
        init(context);//update context for client

        ListenableFuture<MobileServiceUser> mLogin = mClient.login(provider);

        Futures.addCallback(mLogin, new FutureCallback<MobileServiceUser>() {
            @Override
            public void onFailure(Throwable exc) {
                String msg = exc.getMessage();
                if ( msg.equals("User Canceled"))
                    return;

                if ( pd!= null && pd.isShowing())
                    pd.dismiss();
                createAndShowDialog(context, msg, "Error");

                synchronized(mAuthenticationLock)
                {
                    bAuthenticating = false;
                    mAuthenticationLock.notifyAll();
                }

            }
            @Override
            public void onSuccess(MobileServiceUser user) {
                cacheUserToken(context, mClient.getCurrentUser());
                if(!bRefreshCache)//otherwise main activity is launched even from other activity (like shop activity)
                    QueryManager.getUser(context, mClient, mClient.getCurrentUser().getUserId(), pd);//loads user's info and shows MainActivity
                else if ( pd!= null && pd.isShowing())
                    pd.dismiss();
                synchronized(mAuthenticationLock)
                {
                    bAuthenticating = false;
                    mAuthenticationLock.notifyAll();
                }
                ClientUtility.UserId = mClient.getCurrentUser().getUserId();
            }
        });

        return true;
    }

Answer 1

我认为 API 应该有一种在不显示 Activity 的情况下刷新 token 的方法(据我所知，仅在插入凭据时才需要该方法；但 token 刷新不需要凭据)。我正在考虑的另一个解决方案是切换到不同的云服务提供商，放弃 Microsoft Azure:(