import com.vk.sdk.api.VKError; //导入依赖的package包/类
@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
    mTwitterAuthClient.onActivityResult(requestCode, resultCode, data);
    if (!VKSdk.onActivityResult(requestCode, resultCode, data, new VKCallback<VKAccessToken>() {
        @Override
        public void onResult(VKAccessToken token) {
            initUIAfterLogin();
        }

        @Override
        public void onError(VKError error) {
        }
    })) {
        super.onActivityResult(requestCode, resultCode, data);
    } else {
        super.onActivityResult(requestCode, resultCode, data);
    }
}
 

import com.vk.sdk.api.VKError; //导入依赖的package包/类
@Override
public void onClick(View view) {
	setIsLoading(true);
	if (mAttachmentImages != null && VKSdk.getAccessToken() != null) {
		final Long userId = Long.parseLong(VKSdk.getAccessToken().userId);
		VKUploadWallPhotoRequest photoRequest = new VKUploadWallPhotoRequest(mAttachmentImages, userId, 0);
		photoRequest.executeWithListener(new VKRequest.VKRequestListener() {
			@Override
			public void onComplete(VKResponse response) {
				VKPhotoArray photos = (VKPhotoArray) response.parsedModel;
				VKAttachments attachments = new VKAttachments(photos);
				makePostWithAttachments(attachments);
			}

			@Override
			public void onError(VKError error) {
				setIsLoading(false);
				if (mListener != null) {
					mListener.onVkShareError(error);
				}
			}
		});
	} else {
		makePostWithAttachments(null);
	}
}
 

import com.vk.sdk.api.VKError; //导入依赖的package包/类
@Override
public void onActivityResult( int requestCode, int resultCode, Intent data ) {
	if( !VKSdk.onActivityResult( requestCode, resultCode, data, new VKCallback<VKAccessToken>() {
		@Override
		public void onResult( VKAccessToken res ) {
			AIR.log( "AuthFunction::onActivityResult | VK_AUTH_SUCCESS" );
			AIR.dispatchEvent( AIRVKEvent.VK_AUTH_SUCCESS, VKAccessTokenUtils.toJSON( res ) );
		}

		@Override
		public void onError( VKError error ) {
			AIR.log( "AuthFunction::onActivityResult | VK_AUTH_ERROR: " + error.errorMessage + " reason: " + error.errorReason );
			AIR.dispatchEvent( AIRVKEvent.VK_AUTH_ERROR, (error.errorMessage == null) ? "Error - user denied access." : error.errorMessage );
		}
	} ) ) {
		AIR.log( "AuthFunction::onActivityResult | no callback" );
	}
	AndroidActivityWrapper.GetAndroidActivityWrapper().removeActivityResultListener( this );
}
 

import com.vk.sdk.api.VKError; //导入依赖的package包/类
private void removeAudio(VKApiAudio audio, int position) {
    VKApi.audio().delete(VKParameters.from("audio_id", audio.id, "owner_id", audio.owner_id)).executeWithListener(new VKRequest.VKRequestListener() {
        @Override
        public void onComplete(VKResponse response) {
            try {
                int responseCode = response.json.getInt("response");
                if (responseCode == 1) {
                    audioArray.remove(position);
                    adapter.notifyItemRemoved(position);
                    Snackbar.make(binding.getRoot(), R.string.track_removed, Snackbar.LENGTH_SHORT).show();
                }
            } catch (JSONException e) {
                onError(null);
            }
        }

        @Override
        public void onError(VKError error) {
            Snackbar.make(binding.getRoot(), R.string.error_deleting_track, Snackbar.LENGTH_LONG).show();
        }
    });
}
 

import com.vk.sdk.api.VKError; //导入依赖的package包/类
@Override
protected void onActivityResult(final int requestCode, int resultCode, Intent data) {
    if (!VKSdk.onActivityResult(requestCode, resultCode, data, new VKCallback<VKAccessToken>() {
        @Override
        public void onResult(final VKAccessToken accessToken) {
            createUserComponentAndLaunchMainActivity();
        }

        @Override
        public void onError(VKError error) {
            new AlertDialog.Builder(LoginActivity.this)
                    .setMessage("Login failed: " + error.errorReason)
                    .setPositiveButton(android.R.string.ok, null)
                    .show();
        }
    })) {
        super.onActivityResult(requestCode, resultCode, data);
    }
}
 

import com.vk.sdk.api.VKError; //导入依赖的package包/类
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    if (!VKSdk.onActivityResult(requestCode, resultCode, data, new VKCallback<VKAccessToken>() {
        @Override
        public void onResult(VKAccessToken res) {
            Log.i(LOG_TAG, "VKAccessToken: " + res);
            // User passed Authorization
            loadUser("onActivityResult");
        }
        @Override
        public void onError(VKError error) {
            // User didn't pass Authorization
            Log.e(LOG_TAG, "onActivityResult.onError: " + error);
        }
    })) {
        super.onActivityResult(requestCode, resultCode, data);
    }
}
 

import com.vk.sdk.api.VKError; //导入依赖的package包/类
/**
 * Check new access token and sets it as working token
 *
 * @param tokenParams params of token
 * @param renew       flag indicates token renewal
 * @return true if access token was set, or error was provided
 */
private static CheckTokenResult checkAndSetToken(Map<String, String> tokenParams, boolean renew) {

    VKAccessToken token = VKAccessToken.tokenFromParameters(tokenParams);
    if (token == null || token.accessToken == null) {
        if (tokenParams.containsKey(VKAccessToken.SUCCESS)) {
            return CheckTokenResult.Success;
        }

        VKError error = new VKError(tokenParams);
        if (error.errorMessage != null || error.errorReason != null) {
            setAccessTokenError(error);
            return CheckTokenResult.Error;
        }
    } else {
        setAccessToken(token, renew);
        return CheckTokenResult.Success;
    }
    return CheckTokenResult.None;
}
 

import com.vk.sdk.api.VKError; //导入依赖的package包/类
/**
* Check new access token and sets it as working token
* @param tokenParams params of token
* @param renew flag indicates token renewal
   * @return true if access token was set, or error was provided
*/
  private static boolean checkAndSetToken(Map<String, String> tokenParams, boolean renew) {
      VKAccessToken token = VKAccessToken.tokenFromParameters(tokenParams);
      if (token == null || token.accessToken == null) {
          VKError error = new VKError(tokenParams);
          if (error.errorMessage != null || error.errorReason != null) {
              setAccessTokenError(error);
              return true;
          }

      } else {
          setAccessToken(token, renew);
          return true;
      }
      return false;
  }
 

import com.vk.sdk.api.VKError; //导入依赖的package包/类
private boolean performTokenCheck(VKAccessToken token, boolean isUserToken) {
    if (token != null) {
        if (token.isExpired()) {
            mListener.onTokenExpired(token);
        }
        else if (token.accessToken != null) {
            if (isUserToken) mListener.onAcceptUserToken(token);
            return true;
        }
        else {
            VKError error = new VKError(VKError.VK_API_CANCELED);
            error.errorMessage = "User token is invalid";
                mListener.onAccessDenied(error);
        }
    }
    return false;
}
 

import com.vk.sdk.api.VKError; //导入依赖的package包/类
private void makePost(VKAttachments attachments, String message) {
	VKRequest post = VKApi.wall().post(VKParameters.from(VKApiConst.OWNER_ID, "-" + TARGET_GROUP, VKApiConst.ATTACHMENTS, attachments, VKApiConst.MESSAGE, message));
	post.setModelClass(VKWallPostResult.class);
	post.executeWithListener(new VKRequestListener() {
		@Override
		public void onComplete(VKResponse response) {
			if (isAdded()) {
				VKWallPostResult result = (VKWallPostResult) response.parsedModel;
				Intent i = new Intent(Intent.ACTION_VIEW, Uri.parse(String.format("https://vk.com/wall-%d_%s", TARGET_GROUP, result.post_id)));
				startActivity(i);
			}
		}

		@Override
		public void onError(VKError error) {
			showError(error.apiError != null ? error.apiError : error);
		}
	});
}
 

import com.vk.sdk.api.VKError; //导入依赖的package包/类
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    VKCallback<VKAccessToken> callback = new VKCallback<VKAccessToken>() {
        @Override
        public void onResult(VKAccessToken res) {
            // User passed Authorization
            startTestActivity();
        }

        @Override
        public void onError(VKError error) {
            // User didn't pass Authorization
        }
    };

    if (!VKSdk.onActivityResult(requestCode, resultCode, data, callback)) {
        super.onActivityResult(requestCode, resultCode, data);
    }
}
 

import com.vk.sdk.api.VKError; //导入依赖的package包/类
public void setPhoto(final ImageView imageView, final Button button){
    VKParameters params = new VKParameters();
    params.put(VKApiConst.FIELDS, "photo_max_orig");

    VKRequest request = new VKRequest("users.get",params);
    request.executeWithListener(new VKRequest.VKRequestListener() {

        @Override
        public void onComplete(VKResponse response) {
            super.onComplete(response);
            JSONArray resp = null;
            try {
                resp = response.json.getJSONArray("response");
                JSONObject user = resp.getJSONObject(0);
                String photo_max_orig_url = user.getString("photo_max_orig");
                imageView.setVisibility(View.VISIBLE);
                button.setVisibility(View.GONE);
                Glide.with(context).load(photo_max_orig_url).into(imageView);
            } catch (JSONException e) {
                Log.d("VkSdkHelper", String.valueOf(e));
            }
            }

        @Override
        public void onError(VKError error) {
            super.onError(error);
        }
    });
}
 

import com.vk.sdk.api.VKError; //导入依赖的package包/类
public static boolean onActivityResult(int requestCode, int resultCode, @Nullable Intent data, @NonNull VKCallback<VKAccessToken> vkCallback) {
    if (requestCode == VKServiceActivity.VKServiceType.Authorization.getOuterCode()) {
        if (resultCode == VKSdk.RESULT_OK) {
            vkCallback.onResult(VKAccessToken.currentToken());
        } else if (resultCode == VKSdk.RESULT_ERROR) {
            vkCallback.onError((VKError) VKObject.getRegisteredObject(data == null ? 0 : data.getLongExtra(VKSdk.EXTRA_ERROR_ID, 0)));
        }
        return true;
    } else {
        return false;
    }
}
 

import com.vk.sdk.api.VKError; //导入依赖的package包/类
/**
 * Checks if an access token exist and performs a try to use it again
 *
 * @param context            An application context for store an access token
 * @param loginStateCallback if callback specified, {@link VKCallback#onResult(Object)} method will be called after login state changed
 * @return true, if an access token exists and not expired
 */
public static boolean wakeUpSession(@NonNull final Context context, final VKCallback<LoginState> loginStateCallback) {
    final Context appContext = context.getApplicationContext();
    VKUIHelper.setApplicationContext(appContext);

    VKAccessToken token = VKAccessToken.currentToken();

    if (token != null && token.accessToken != null && !token.isExpired()) {
        forceLoginState(LoginState.Pending, loginStateCallback);
        trackVisitor(new VKRequest.VKRequestListener() {
            @Override
            public void onComplete(VKResponse response) {
                updateLoginState(context, loginStateCallback);
            }

            @Override
            public void onError(VKError error) {
                //Possible double call of access token invalid
                if (error != null && error.apiError != null && error.apiError.errorCode == 5) {
                    onAccessTokenIsInvalid(appContext);
                }
                updateLoginState(context, loginStateCallback);
            }
        });
        return true;
    }
    updateLoginState(context, loginStateCallback);
    return false;
}
 

import com.vk.sdk.api.VKError; //导入依赖的package包/类
@Override
public void onError(VKError error) {
    synchronized (this.syncObj) {
        try {
            listener.onError(error);
        } catch (Exception e) {
            // nothing
        }
        isFinish = true;
        syncObj.notifyAll();
    }
}
 

import com.vk.sdk.api.VKError; //导入依赖的package包/类
public void show(@NonNull Activity activity, Bundle bundle, int reqCode, @Nullable VKError vkError) {
	mVkError = vkError;
	mBundle = bundle;
	mReqCode = reqCode;
	mView = View.inflate(activity, R.layout.vk_open_auth_dialog, null);

	mProgress = mView.findViewById(R.id.progress);
	mWebView = (WebView) mView.findViewById(R.id.copyUrl);

	final Dialog dialog = new Dialog(activity, R.style.VKAlertDialog);
	dialog.setContentView(mView);
	dialog.setOnCancelListener(new DialogInterface.OnCancelListener() {
		@Override
		public void onCancel(DialogInterface dialogInterface) {
			dialog.dismiss();
		}
	});
	dialog.setOnDismissListener(this);
	if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
		dialog.getWindow().setStatusBarColor(Color.TRANSPARENT);
	}

	mDialog = dialog;
	mDialog.show();

	loadPage();
}
 

import com.vk.sdk.api.VKError; //导入依赖的package包/类
public static void interruptWithError(Context ctx, VKError apiError, VKServiceType type) {
    Intent intent = createIntent(ctx, type);
    intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
    intent.putExtra(KEY_REQUEST, apiError.registerObject());
    if (ctx != null) {
        ctx.startActivity(intent);
    }
}
 

import com.vk.sdk.api.VKError; //导入依赖的package包/类
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    if (requestCode == VKServiceType.Authorization.getOuterCode() || requestCode == VKServiceType.Validation.getOuterCode()) {
        VKSdk.processActivityResult(this, resultCode, data, new VKCallback<VKAccessToken>() {
            @Override
            public void onResult(VKAccessToken res) {
                setResult(VKSdk.RESULT_OK);
                finish();
            }

            @Override
            public void onError(VKError error) {
                Object o = VKObject.getRegisteredObject(getRequestId());
                if (o instanceof VKError) {
                    VKError vkError = ((VKError) o);
                    if (vkError.request != null) {
                        vkError.request.cancel();
                        if (vkError.request.requestListener != null) {
                            vkError.request.requestListener.onError(error);
                        }
                    }
                }

                if (error != null) {
                    setResult(VKSdk.RESULT_ERROR, getIntent().putExtra(VKSdk.EXTRA_ERROR_ID, error.registerObject()));
                } else {
                    setResult(VKSdk.RESULT_ERROR);
                }
                finish();
            }
        });
    }
}
 

import com.vk.sdk.api.VKError; //导入依赖的package包/类
@Override
public FREObject call( FREContext context, FREObject[] args ) {
	super.call( context, args );

	boolean enableLogs = FREObjectUtils.getBoolean( args[1] );
	AIR.setLogEnabled( enableLogs );
	VKSdk.DEBUG = enableLogs;
	int appId = Integer.valueOf( FREObjectUtils.getString( args[0] ) );

	AIR.log( "Initializing VKSdk" );

	Activity activity = AIR.getContext().getActivity();

	AIR.startAccessTokenTracker();
	VKSdk.customInitialize( activity, appId, "" );
	VKSdk.wakeUpSession( activity, new VKCallback<VKSdk.LoginState>() {
		@Override
		public void onResult( VKSdk.LoginState res ) {
			AIR.log( "VKSdk.wakeUpSession::onResult " + res );
			AIR.notifyTokenChange( VKAccessToken.currentToken() );
		}

		@Override
		public void onError( VKError error ) {
			AIR.log( "VKSdk.wakeUpSession::onError " + error.errorReason );
			AIR.notifyTokenChange( VKAccessToken.currentToken() );
		}
	} );

	return null;
}
 

import com.vk.sdk.api.VKError; //导入依赖的package包/类
@Override
public void run() {
    if (mCheckUserInstallAnswer == CHECK_USER_INSTALL_ANSWER_VK
            || mCheckUserInstallAnswer == CHECK_USER_INSTALL_ANSWER_VK_FORCE) {
        for (final String receipt : purchases) {

            final String platform = "android";
            final int appId = getIntResByName(mAppCtx, VKSdk.SDK_APP_ID);
            final String deviceId = getDeviceId(mAppCtx);

            VKRequest request = new VKRequest(METHOD_NAME_SAVE_TRANSACTION);
            request.addExtraParameter(PLATFORM, platform);
            request.addExtraParameter(APP_ID, appId);
            if (!TextUtils.isEmpty(deviceId)) {
                request.addExtraParameter(DEVICE_ID, deviceId);
            }
            request.addExtraParameter(RECEIPT, receipt);

            request.executeSyncWithListener(new VKRequest.VKRequestListener() {
                @Override
                public void onComplete(VKResponse response) {
                    VKPaymentsDatabase.getInstance(mAppCtx).deletePurchase(receipt);
                    log("apps.saveTransaction successful response=" + response.json);
                }

                @Override
                public void onError(VKError error) {
                    log("apps.saveTransaction error=" + (error.apiError == null ? error.errorMessage : error.apiError.errorMessage));
                }
            });
        }
    }
}