Java Code Examples for androidx.appcompat.app.AppCompatActivity#RESULT_OK

@Override
public void onActivityResult(Activity activity, int requestCode, int resultCode, Intent data) {

  if (requestCode == 1 && resultCode == AppCompatActivity.RESULT_OK) {
    String filePath = data.getStringExtra(FilePickerActivity.RESULT_FILE_PATH);

    if (onDone != null) {
      onDone.invoke(filePath);
    }

    onDone = null;
  } else if (requestCode == 1 && resultCode == AppCompatActivity.RESULT_CANCELED) {
    if (onCancel != null) {
      onCancel.invoke();
    }

    onCancel = null;
  }
}
 

@Override
public void onActivityResult(Activity activity, int requestCode, int resultCode, Intent data) {

  if (resultCode == AppCompatActivity.RESULT_OK) {
    String filePath = Environment.getExternalStorageDirectory() + "/recorded_audio.wav";
    
    if (_onDone != null) {
      _onDone.invoke(filePath);
    }

    _onDone = null;
  } else if (resultCode == AppCompatActivity.RESULT_CANCELED) {
    if (_onCancel != null) {
      _onCancel.invoke();
    }

    _onCancel = null;
  }
}
 

static String activityResponseCodeToString(int respCode) {
    switch (respCode) {
        case AppCompatActivity.RESULT_OK:
            return "RESULT_OK";
        case AppCompatActivity.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 void onActivityResult(final BraintreeFragment fragment, int resultCode, Intent data) {
    if (resultCode == AppCompatActivity.RESULT_OK) {
        fragment.sendAnalyticsEvent("pay-with-venmo.app-switch.success");
        String nonce = data.getStringExtra(EXTRA_PAYMENT_METHOD_NONCE);

        if (shouldVault(fragment.getApplicationContext()) && fragment.getAuthorization() instanceof ClientToken) {
            vault(fragment, nonce);
        } else {
            String venmoUsername = data.getStringExtra(EXTRA_USERNAME);
            VenmoAccountNonce venmoAccountNonce = new VenmoAccountNonce(nonce, venmoUsername, venmoUsername);
            fragment.postCallback(venmoAccountNonce);
        }
    } else if (resultCode == AppCompatActivity.RESULT_CANCELED) {
        fragment.sendAnalyticsEvent("pay-with-venmo.app-switch.canceled");
    }
}
 

@Override
@SuppressLint("NewApi")
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
  super.onActivityResult(requestCode, resultCode, data);

  if (requestCode == CropImage.PICK_IMAGE_CHOOSER_REQUEST_CODE
      && resultCode == AppCompatActivity.RESULT_OK) {
    Uri imageUri = CropImage.getPickImageResultUri(this, data);

    // For API >= 23 we need to check specifically that we have permissions to read external
    // storage,
    // but we don't know if we need to for the URI so the simplest is to try open the stream and
    // see if we get error.
    boolean requirePermissions = false;
    if (CropImage.isReadExternalStoragePermissionsRequired(this, imageUri)) {

      // request permissions and handle the result in onRequestPermissionsResult()
      requirePermissions = true;
      mCropImageUri = imageUri;
      requestPermissions(
          new String[] {Manifest.permission.READ_EXTERNAL_STORAGE},
          CropImage.PICK_IMAGE_PERMISSIONS_REQUEST_CODE);
    } else {

      mCurrentFragment.setImageUri(imageUri);
    }
  }
}
 

/**
 * The result from PayPal's request.
 *
 * @param fragment A {@link BraintreeFragment} used to process the request.
 * @param data Data associated with the result.
 */
protected static void onActivityResult(final BraintreeFragment fragment, int resultCode, Intent data) {
    Request request = getPersistedRequest(fragment.getApplicationContext());
    String paymentType = paymentTypeForRequest(request);
    String switchType = switchTypeForIntent(data);
    String eventPrefix = paymentType + "." + switchType;

    if (resultCode == AppCompatActivity.RESULT_OK && data != null && request != null) {
        Result result = PayPalOneTouchCore.parseResponse(fragment.getApplicationContext(), request, data);
        switch (result.getResultType()) {
            case Error:
                fragment.postCallback(new BrowserSwitchException(result.getError().getMessage()));
                fragment.sendAnalyticsEvent(eventPrefix + ".failed");
                break;
            case Cancel:
                fragment.postCancelCallback(BraintreeRequestCodes.PAYPAL);
                fragment.sendAnalyticsEvent(eventPrefix + ".canceled");
                break;
            case Success:
                onSuccess(fragment, data, request, result);
                fragment.sendAnalyticsEvent(eventPrefix + ".succeeded");
                break;
        }
    } else {
        fragment.sendAnalyticsEvent(eventPrefix + ".canceled");

        if (resultCode != AppCompatActivity.RESULT_CANCELED) {
            fragment.postCancelCallback(BraintreeRequestCodes.PAYPAL);
        }
    }
}
 

@Override
public void onBrowserSwitchResult(int requestCode, BrowserSwitchResult browserSwitchResult, @Nullable Uri uri) {
    String type = "";
    Intent intent = new Intent()
            .putExtra(EXTRA_WAS_BROWSER_SWITCH_RESULT, true);

    switch (requestCode) {
        case BraintreeRequestCodes.PAYPAL:
            type = "paypal";
            break;
        case BraintreeRequestCodes.THREE_D_SECURE:
            type =  "three-d-secure";
            break;
        case BraintreeRequestCodes.LOCAL_PAYMENT:
            type = "local-payment";
            break;
    }

    int resultCode = AppCompatActivity.RESULT_FIRST_USER;
    if (browserSwitchResult == BrowserSwitchResult.OK) {
        resultCode = AppCompatActivity.RESULT_OK;
        sendAnalyticsEvent(type + ".browser-switch.succeeded");
    } else if (browserSwitchResult == BrowserSwitchResult.CANCELED) {
        resultCode = AppCompatActivity.RESULT_CANCELED;
        sendAnalyticsEvent(type + ".browser-switch.canceled");
    } else if (browserSwitchResult == BrowserSwitchResult.ERROR) {
        if (browserSwitchResult.getErrorMessage().startsWith("No installed activities")) {
            sendAnalyticsEvent(type + ".browser-switch.failed.no-browser-installed");
        } else {
            sendAnalyticsEvent(type + ".browser-switch.failed.not-setup");
        }
    }

    onActivityResult(requestCode, resultCode, intent.setData(uri));
}
 

protected static void onActivityResult(final BraintreeFragment fragment, int resultCode, Intent data) {
    PayPalAccountNonce payPalAccountNonce = PayPalTwoFactorAuthSharedPreferences.getPersistedPayPalAccountNonce(fragment);

    if (resultCode == AppCompatActivity.RESULT_OK && data != null && payPalAccountNonce != null) {
        String host = null;
        Uri intentData = data.getData();
        if (intentData != null) {
            host = intentData.getHost();
        }

        if (host != null) {
            switch (host) {
                case SUCCESS_PATH:
                    fragment.sendAnalyticsEvent("paypal-two-factor.browser-switch.succeeded");
                    fragment.postCallback(payPalAccountNonce);
                    break;
                case CANCEL_PATH:
                    fragment.sendAnalyticsEvent("paypal-two-factor.browser-switch.canceled");
                    fragment.postCancelCallback(BraintreeRequestCodes.PAYPAL_TWO_FACTOR_AUTH);
                    break;
                default:
                    fragment.sendAnalyticsEvent("paypal-two-factor.browser-switch.failed");
                    fragment.postCallback(new BraintreeException("Host path unknown: " + host));
                    break;
            }
        } else {
            fragment.sendAnalyticsEvent("paypal-two-factor.browser-switch.failed");
            fragment.postCallback(new BraintreeException("Host missing from browser switch response."));
        }
    } else {
        fragment.sendAnalyticsEvent("paypal-two-factor.browser-switch.canceled");

        fragment.postCancelCallback(BraintreeRequestCodes.PAYPAL_TWO_FACTOR_AUTH);
    }
}
 

/**
 * 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 == AppCompatActivity.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 == AppCompatActivity.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));
    }
}