Java GamesActivityResultCodes.RESULT_RECONNECT_REQUIRED屬性代碼示例

static String activityResponseCodeToString(int respCode) {
    switch (respCode) {
        case Activity.RESULT_OK:
            return "RESULT_OK";
        case Activity.RESULT_CANCELED:
            return "RESULT_CANCELED";
        case GamesActivityResultCodes.RESULT_APP_MISCONFIGURED:
            return "RESULT_APP_MISCONFIGURED";
        case GamesActivityResultCodes.RESULT_LEFT_ROOM:
            return "RESULT_LEFT_ROOM";
        case GamesActivityResultCodes.RESULT_LICENSE_FAILED:
            return "RESULT_LICENSE_FAILED";
        case GamesActivityResultCodes.RESULT_RECONNECT_REQUIRED:
            return "RESULT_RECONNECT_REQUIRED";
        case GamesActivityResultCodes.RESULT_SIGN_IN_FAILED:
            return "SIGN_IN_FAILED";
        default:
            return String.valueOf(respCode);
    }
}
 

static String activityResponseCodeToString(int respCode) {
    switch (respCode) {
        case Activity.RESULT_OK:
        return "RESULT_OK";
        case Activity.RESULT_CANCELED:
        return "RESULT_CANCELED";
        case GamesActivityResultCodes.RESULT_APP_MISCONFIGURED:
        return "RESULT_APP_MISCONFIGURED";
        case GamesActivityResultCodes.RESULT_LEFT_ROOM:
        return "RESULT_LEFT_ROOM";
        case GamesActivityResultCodes.RESULT_LICENSE_FAILED:
        return "RESULT_LICENSE_FAILED";
        case GamesActivityResultCodes.RESULT_RECONNECT_REQUIRED:
        return "RESULT_RECONNECT_REQUIRED";
        case GamesActivityResultCodes.RESULT_SIGN_IN_FAILED:
        return "SIGN_IN_FAILED";
        default:
        return String.valueOf(respCode);
    }
}
 

static String activityResponseCodeToString(int respCode) {
  switch (respCode) {
    case Activity.RESULT_OK:
      return "RESULT_OK";
    case Activity.RESULT_CANCELED:
      return "RESULT_CANCELED";
    case GamesActivityResultCodes.RESULT_APP_MISCONFIGURED:
      return "RESULT_APP_MISCONFIGURED";
    case GamesActivityResultCodes.RESULT_LEFT_ROOM:
      return "RESULT_LEFT_ROOM";
    case GamesActivityResultCodes.RESULT_LICENSE_FAILED:
      return "RESULT_LICENSE_FAILED";
    case GamesActivityResultCodes.RESULT_RECONNECT_REQUIRED:
      return "RESULT_RECONNECT_REQUIRED";
    case GamesActivityResultCodes.RESULT_SIGN_IN_FAILED:
      return "SIGN_IN_FAILED";
    default:
      return String.valueOf(respCode);
  }
}
 

private void handleAchievementsUIRequest( int resultCode ) {
	/* UI was not shown, client in inconsistent state, needs reconnect */
	if( resultCode == GamesActivityResultCodes.RESULT_RECONNECT_REQUIRED ) {
		AIR.log( "GameServices | client must be reconnected before showing achievements UI" );
		mPendingAchievementsUI = true;
		mGoogleApiClient.reconnect();
	} else {
		AIR.dispatchEvent( GameServicesEvent.ACHIEVEMENT_UI_HIDE );
	}
}
 

private void handleLeaderboardsUIRequest( int resultCode ) {
	/* UI was not shown, client in inconsistent state, needs reconnect */
	if( resultCode == GamesActivityResultCodes.RESULT_RECONNECT_REQUIRED ) {
		AIR.log( "GameServices | client must be reconnected before showing leaderboards UI" );
		mPendingLeaderboardsUI = true;
		mGoogleApiClient.reconnect();
	} else {
		mPendingLeaderboardId = null;
		AIR.dispatchEvent( GameServicesEvent.LEADERBOARDS_UI_HIDE );
	}
}
 

public void onActivityResult(int requestCode, int resultCode, Intent data) {
    helper.onActivityResult(requestCode, resultCode, data);
    if (multiplayer != null) {
        multiplayer.onActivityResult(requestCode, resultCode, data);
    }
    if ((requestCode == GoogleAchievements.ACHIEVEMENTS_REQUEST_CODE
        || requestCode == LEADERBOARD_REQUEST_CODE)
        && resultCode == GamesActivityResultCodes.RESULT_RECONNECT_REQUIRED) {
        onSignedOutFromOutside();
    }
}
 

/**
 * Handle activity result. Call this method from your Activity's
 * onActivityResult callback. If the activity result pertains to the sign-in
 * process, processes it appropriately.
 */
public void onActivityResult(int requestCode, int responseCode,
                             Intent intent) {
    debugLog("onActivityResult: req="
            + (requestCode == RC_RESOLVE ? "RC_RESOLVE" : String
            .valueOf(requestCode)) + ", resp="
            + GameHelperUtils.activityResponseCodeToString(responseCode));
    if (requestCode != RC_RESOLVE) {
        debugLog("onActivityResult: request code not meant for us. Ignoring.");
        return;
    }

    // no longer expecting a resolution
    mExpectingResolution = false;

    if (!mConnecting) {
        debugLog("onActivityResult: ignoring because we are not connecting.");
        return;
    }

    // We're coming back from an activity that was launched to resolve a
    // connection problem. For example, the sign-in UI.
    if (responseCode == Activity.RESULT_OK) {
        // Ready to try to connect again.
        debugLog("onAR: Resolution was RESULT_OK, so connecting current client again.");
        connect();
    } else if (responseCode == GamesActivityResultCodes.RESULT_RECONNECT_REQUIRED) {
        debugLog("onAR: Resolution was RECONNECT_REQUIRED, so reconnecting.");
        connect();
    } else if (responseCode == Activity.RESULT_CANCELED) {
        // User cancelled.
        debugLog("onAR: Got a cancellation result, so disconnecting.");
        mSignInCancelled = true;
        mConnectOnStart = false;
        mUserInitiatedSignIn = false;
        mSignInFailureReason = null; // cancelling is not a failure!
        mConnecting = false;
        mGoogleApiClient.disconnect();

        // increment # of cancellations
        int prevCancellations = getSignInCancellations();
        int newCancellations = incrementSignInCancellations();
        debugLog("onAR: # of cancellations " + prevCancellations + " --> "
                + newCancellations + ", max " + mMaxAutoSignInAttempts);

        notifyListener(false);
    } else {
        // Whatever the problem we were trying to solve, it was not
        // solved. So give up and show an error message.
        debugLog("onAR: responseCode="
                + GameHelperUtils
                .activityResponseCodeToString(responseCode)
                + ", so giving up.");
        giveUp(new SignInFailureReason(mConnectionResult.getErrorCode(),
                responseCode));
    }
}
 

/**
 * Handle activity result. Call this method from your Activity's
 * onActivityResult callback. If the activity result pertains to the sign-in
 * process, processes it appropriately.
 */
public void onActivityResult(
    int requestCode, int responseCode,
    Intent intent)
{
    debugLog("onActivityResult: req="
        + (
        requestCode == RC_RESOLVE ? "RC_RESOLVE" : String
            .valueOf(requestCode)) + ", resp="
        + GameHelperUtils.activityResponseCodeToString(responseCode));
    if (requestCode != RC_RESOLVE)
    {
        debugLog("onActivityResult: request code not meant for us. Ignoring.");
        return;
    }

    // no longer expecting a resolution
    this.mExpectingResolution = false;

    if (!this.mConnecting)
    {
        debugLog("onActivityResult: ignoring because we are not connecting.");
        return;
    }

    // We're coming back from an activity that was launched to resolve a
    // connection problem. For example, the sign-in UI.
    if (responseCode == Activity.RESULT_OK)
    {
        // Ready to try to connect again.
        debugLog("onAR: Resolution was RESULT_OK, so connecting current client again.");
        connect();
    }
    else if (responseCode == GamesActivityResultCodes.RESULT_RECONNECT_REQUIRED)
    {
        debugLog("onAR: Resolution was RECONNECT_REQUIRED, so reconnecting.");
        connect();
    }
    else if (responseCode == Activity.RESULT_CANCELED)
    {
        // User cancelled.
        debugLog("onAR: Got a cancellation result, so disconnecting.");
        this.mSignInCancelled = true;
        this.mConnectOnStart = false;
        this.mUserInitiatedSignIn = false;
        this.mSignInFailureReason = null; // cancelling is not a failure!
        this.mConnecting = false;
        this.mGoogleApiClient.disconnect();

        // increment # of cancellations
        int prevCancellations = getSignInCancellations();
        int newCancellations = incrementSignInCancellations();
        debugLog("onAR: # of cancellations " + prevCancellations + " --> "
            + newCancellations + ", max " + this.mMaxAutoSignInAttempts);

        notifyListener(false);
    }
    else
    {
        // Whatever the problem we were trying to solve, it was not
        // solved. So give up and show an error message.
        debugLog("onAR: responseCode="
            + GameHelperUtils
            .activityResponseCodeToString(responseCode)
            + ", so giving up.");
        giveUp(new SignInFailureReason(
            this.mConnectionResult.getErrorCode(),
            responseCode));
    }
}
 

/**
 * Handle activity result. Call this method from your Activity's
 * onActivityResult callback. If the activity result pertains to the sign-in
 * process, processes it appropriately.
 */
public void onActivityResult(int requestCode, int responseCode, Intent intent) {
    debugLog("onActivityResult: req=" + (requestCode == RC_RESOLVE ? "RC_RESOLVE" :
            String.valueOf(requestCode)) + ", resp=" +
            activityResponseCodeToString(responseCode));
    if (requestCode != RC_RESOLVE) {
        debugLog("onActivityResult: request code not meant for us. Ignoring.");
        return;
    }

    // no longer expecting a resolution
    mExpectingResolution = false;

    if (mState != STATE_CONNECTING) {
        debugLog("onActivityResult: ignoring because state isn't STATE_CONNECTING (" +
                "it's " + STATE_NAMES[mState] + ")");
        return;
    }

    // We're coming back from an activity that was launched to resolve a
    // connection problem. For example, the sign-in UI.
    if (responseCode == Activity.RESULT_OK) {
        // Ready to try to connect again.
        debugLog("onAR: Resolution was RESULT_OK, so connecting current client again.");
        connectCurrentClient();
    } else if (responseCode == GamesActivityResultCodes.RESULT_RECONNECT_REQUIRED) {
        debugLog("onAR: Resolution was RECONNECT_REQUIRED, so reconnecting.");
        connectCurrentClient();
    } else if (responseCode == Activity.RESULT_CANCELED) {
        // User cancelled.
        debugLog("onAR: Got a cancellation result, so disconnecting.");
        mAutoSignIn = false;
        mUserInitiatedSignIn = false;
        mSignInFailureReason = null; // cancelling is not a failure!
        killConnections();
        notifyListener(false);
    } else {
        // Whatever the problem we were trying to solve, it was not
        // solved. So give up and show an error message.
        debugLog("onAR: responseCode=" + activityResponseCodeToString(responseCode) +
                ", so giving up.");
        giveUp(new SignInFailureReason(mConnectionResult.getErrorCode(), responseCode));
    }
}
 

/**
 * Handle activity result. Call this method from your Activity's
 * onActivityResult callback. If the activity result pertains to the sign-in
 * process, processes it appropriately.
 */
public void onActivityResult(int requestCode, int responseCode, Intent intent) {
    debugLog("onActivityResult: req=" + (requestCode == RC_RESOLVE ? "RC_RESOLVE" :
            String.valueOf(requestCode)) + ", resp=" +
            activityResponseCodeToString(responseCode));
    if (requestCode != RC_RESOLVE) {
        debugLog("onActivityResult: request code not meant for us. Ignoring.");
        return;
    }

    // no longer expecting a resolution
    mExpectingResolution = false;

    if (mState != STATE_CONNECTING) {
        debugLog("onActivityResult: ignoring because state isn't STATE_CONNECTING (" +
                "it's " + STATE_NAMES[mState] + ")");
        return;
    }

    // We're coming back from an activity that was launched to resolve a
    // connection problem. For example, the sign-in UI.
    if (responseCode == Activity.RESULT_OK) {
        // Ready to try to connect again.
        debugLog("onAR: Resolution was RESULT_OK, so connecting current client again.");
        connectCurrentClient();
    } else if (responseCode == GamesActivityResultCodes.RESULT_RECONNECT_REQUIRED) {
        debugLog("onAR: Resolution was RECONNECT_REQUIRED, so reconnecting.");
        connectCurrentClient();
    } else if (responseCode == Activity.RESULT_CANCELED) {
        // User cancelled.
        debugLog("onAR: Got a cancellation result, so disconnecting.");
        mAutoSignIn = false;
        mUserInitiatedSignIn = false;
        mSignInFailureReason = null; // cancelling is not a failure!
        killConnections();
        notifyListener(false);
    } else {
        // Whatever the problem we were trying to solve, it was not
        // solved. So give up and show an error message.
        debugLog("onAR: responseCode="  + activityResponseCodeToString(responseCode) +
                    ", so giving up.");
        giveUp(new SignInFailureReason(mConnectionResult.getErrorCode(), responseCode));
    }
}
 

/**
 * Handle activity result. Call this method from your Activity's
 * onActivityResult callback. If the activity result pertains to the sign-in
 * process, processes it appropriately.
 */
public void onActivityResult(int requestCode, int responseCode,
        Intent intent) {
    debugLog("onActivityResult: req="
            + (requestCode == RC_RESOLVE ? "RC_RESOLVE" : String
                    .valueOf(requestCode)) + ", resp="
            + GameHelperUtils.activityResponseCodeToString(responseCode));
    if (requestCode != RC_RESOLVE) {
        debugLog("onActivityResult: request code not meant for us. Ignoring.");
        return;
    }

    // no longer expecting a resolution
    mExpectingResolution = false;

    if (!mConnecting) {
        debugLog("onActivityResult: ignoring because we are not connecting.");
        return;
    }

    // We're coming back from an activity that was launched to resolve a
    // connection problem. For example, the sign-in UI.
    if (responseCode == Activity.RESULT_OK) {
        // Ready to try to connect again.
        debugLog("onAR: Resolution was RESULT_OK, so connecting current client again.");
        connect();
    } else if (responseCode == GamesActivityResultCodes.RESULT_RECONNECT_REQUIRED) {
        debugLog("onAR: Resolution was RECONNECT_REQUIRED, so reconnecting.");
        connect();
    } else if (responseCode == Activity.RESULT_CANCELED) {
        // User cancelled.
        debugLog("onAR: Got a cancellation result, so disconnecting.");
        mSignInCancelled = true;
        mConnectOnStart = false;
        mUserInitiatedSignIn = false;
        mSignInFailureReason = null; // cancelling is not a failure!
        mConnecting = false;
        mGoogleApiClient.disconnect();

        // increment # of cancellations
        int prevCancellations = getSignInCancellations();
        int newCancellations = incrementSignInCancellations();
        debugLog("onAR: # of cancellations " + prevCancellations + " --> "
                + newCancellations + ", max " + mMaxAutoSignInAttempts);

        notifyListener(false);
    } else {
        // Whatever the problem we were trying to solve, it was not
        // solved. So give up and show an error message.
        debugLog("onAR: responseCode="
                + GameHelperUtils
                        .activityResponseCodeToString(responseCode)
                + ", so giving up.");
        giveUp(new SignInFailureReason(mConnectionResult.getErrorCode(),
                responseCode));
    }
}
 

/**
* Handle activity result. Call this method from your Activity's
* onActivityResult callback. If the activity result pertains to the sign-in
* process, processes it appropriately.
*/
public void onActivityResult(int requestCode, int responseCode, Intent intent) {
    debugLog("onActivityResult: req=" + (requestCode == RC_RESOLVE ? "RC_RESOLVE" :
    String.valueOf(requestCode)) + ", resp=" +
    activityResponseCodeToString(responseCode));
    if (requestCode != RC_RESOLVE) {
        debugLog("onActivityResult: request code not meant for us. Ignoring.");
        return;
    }

    // no longer expecting a resolution
    mExpectingResolution = false;

    if (mState != STATE_CONNECTING) {
        debugLog("onActivityResult: ignoring because state isn't STATE_CONNECTING (" +
        "it's " + STATE_NAMES[mState] + ")");
        return;
    }

    // We're coming back from an activity that was launched to resolve a
    // connection problem. For example, the sign-in UI.
    if (responseCode == Activity.RESULT_OK) {
        // Ready to try to connect again.
        debugLog("onAR: Resolution was RESULT_OK, so connecting current client again.");
        connectCurrentClient();
    } else if (responseCode == GamesActivityResultCodes.RESULT_RECONNECT_REQUIRED) {
        debugLog("onAR: Resolution was RECONNECT_REQUIRED, so reconnecting.");
        connectCurrentClient();
    } else if (responseCode == Activity.RESULT_CANCELED) {
        // User cancelled.
        debugLog("onAR: Got a cancellation result, so disconnecting.");
        mAutoSignIn = false;
        mUserInitiatedSignIn = false;
        mSignInFailureReason = null; // cancelling is not a failure!
        killConnections();
        notifyListener(false);
    } else {
        // Whatever the problem we were trying to solve, it was not
        // solved. So give up and show an error message.
        debugLog("onAR: responseCode="  + activityResponseCodeToString(responseCode) +
        ", so giving up.");
        giveUp(new SignInFailureReason(mConnectionResult.getErrorCode(), responseCode));
    }
}
 

/**
 * Handle activity result. Call this method from your Activity's
 * onActivityResult callback. If the activity result pertains to the sign-in
 * process, processes it appropriately.
 */
public void onActivityResult(int requestCode, int responseCode,
    Intent intent) {
  debugLog("onActivityResult: req="
      + (requestCode == RC_RESOLVE ? "RC_RESOLVE" : String
          .valueOf(requestCode)) + ", resp="
      + GameHelperUtils.activityResponseCodeToString(responseCode));
  if (requestCode != RC_RESOLVE) {
    debugLog("onActivityResult: request code not meant for us. Ignoring.");
    return;
  }

  // no longer expecting a resolution
  mExpectingResolution = false;

  if (!mConnecting) {
    debugLog("onActivityResult: ignoring because we are not connecting.");
    return;
  }

  // We're coming back from an activity that was launched to resolve a
  // connection problem. For example, the sign-in UI.
  if (responseCode == Activity.RESULT_OK) {
    // Ready to try to connect again.
    debugLog("onAR: Resolution was RESULT_OK, so connecting current client again.");
    connect();
  } else if (responseCode == GamesActivityResultCodes.RESULT_RECONNECT_REQUIRED) {
    debugLog("onAR: Resolution was RECONNECT_REQUIRED, so reconnecting.");
    connect();
  } else if (responseCode == Activity.RESULT_CANCELED) {
    // User cancelled.
    debugLog("onAR: Got a cancellation result, so disconnecting.");
    mSignInCancelled = true;
    mConnectOnStart = false;
    mUserInitiatedSignIn = false;
    mSignInFailureReason = null; // cancelling is not a failure!
    mConnecting = false;
    mGoogleApiClient.disconnect();

    // increment # of cancellations
    int prevCancellations = getSignInCancellations();
    int newCancellations = incrementSignInCancellations();
    debugLog("onAR: # of cancellations " + prevCancellations + " --> "
        + newCancellations + ", max " + mMaxAutoSignInAttempts);

    notifyListener(false);
  } else {
    // Whatever the problem we were trying to solve, it was not
    // solved. So give up and show an error message.
    debugLog("onAR: responseCode="
        + GameHelperUtils
            .activityResponseCodeToString(responseCode)
        + ", so giving up.");
    giveUp(new SignInFailureReason(mConnectionResult.getErrorCode(),
        responseCode));
  }
}