Java Code Examples for android.support.v4.util.Pair#create()

public static void transitionToQuestionDetail(Activity activity, Question question, View title, View questionDes) {
    //获取字符串标识转场的控件
    String titleTransitionName = activity.getResources().getString(R.string.question_title_transition);
    Pair<View, String> titlePair = Pair.create(title, titleTransitionName);
    ActivityOptionsCompat activityOptionsCompat = null;
    //如果问题描述控件不可见，则不执行动画效果
    if (questionDes.getVisibility() == View.VISIBLE) {
        String descTransitionName = activity.getResources().getString(R.string.question_des_transition);
        Pair<View, String> descPair = Pair.create(questionDes, descTransitionName);
        activityOptionsCompat= ActivityOptionsCompat
                .makeSceneTransitionAnimation(activity, titlePair, descPair);
    } else {
        activityOptionsCompat= ActivityOptionsCompat
                .makeSceneTransitionAnimation(activity, titlePair);
    }
    Intent intent = new Intent(activity, QuestionDetailActivity.class);
    intent.putExtra(Constant.EXTRA_QUESTION, question.toString());
    ActivityCompat.startActivity(activity, intent, activityOptionsCompat.toBundle());
}
 

/**
 * Determines if this NavDestination has a deep link matching the given Uri.
 * @param uri The Uri to match against all deep links added in {@link #addDeepLink(String)}
 * @return The matching {@link NavDestination} and the appropriate {@link Bundle} of arguments
 * extracted from the Uri, or null if no match was found.
 */
@Nullable
Pair<NavDestination, Bundle> matchDeepLink(@NonNull Uri uri) {
    if (mDeepLinks == null) {
        return null;
    }
    for (NavDeepLink deepLink : mDeepLinks) {
        Bundle matchingArguments = deepLink.getMatchingArguments(uri);
        if (matchingArguments != null) {
            return Pair.create(this, matchingArguments);
        }
    }
    return null;
}
 

private Pair<Integer, Integer> getFabPosition(View fromView, View containerView) {
  int[] fromLocation = new int[2];
  fromView.getLocationInWindow(fromLocation);

  int[] containerLocation = new int[2];
  containerView.getLocationInWindow(containerLocation);

  int relativeLeft = fromLocation[0] - containerLocation[0];
  int relativeTop = fromLocation[1] - containerLocation[1];

  int mCx = fromView.getWidth() / 2 + relativeLeft;
  int mCy = fromView.getHeight() / 2 + relativeTop;
  return Pair.create(mCx, mCy);
}
 

private Pair<Integer, Integer> getViewPosition(View fromView, View containerView) {
  int[] fromLocation = new int[2];
  fromView.getLocationInWindow(fromLocation);

  int[] containerLocation = new int[2];
  containerView.getLocationInWindow(containerLocation);

  int relativeLeft = fromLocation[0] - containerLocation[0];
  int relativeTop = fromLocation[1] - containerLocation[1];

  int mCx = relativeLeft + 20;
  int mCy = fromView.getHeight() / 2 + relativeTop;
  return Pair.create(mCx, mCy);
}
 

private static Bundle getOptionsBundle(final Activity activity,
                                       final View[] sharedElements) {
    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) return null;
    if (sharedElements == null) return null;
    int len = sharedElements.length;
    if (len <= 0) return null;
    @SuppressWarnings("unchecked")
    Pair<View, String>[] pairs = new Pair[len];
    for (int i = 0; i < len; i++) {
        pairs[i] = Pair.create(sharedElements[i], sharedElements[i].getTransitionName());
    }
    return ActivityOptionsCompat.makeSceneTransitionAnimation(activity, pairs).toBundle();
}
 

@Nullable
public Pair<Integer, BackStackEntry> pop() {
  BackStack backStack = peekBackStack();
  if (backStack == null) {
    return null;
  }
  return Pair.create(backStack.hostId, pop(backStack));
}
 

@Override
public void onClick(View v) {
    if (isInQuickSelectMode()) {
        toggleChecked(getAdapterPosition());
    } else {
        Pair[] albumPairs = new Pair[]{
                Pair.create(image,
                        activity.getResources().getString(R.string.transition_album_art)
                )};
        NavigationUtil.goToAlbum(activity, dataSet.get(getAdapterPosition()).getId(), albumPairs);
    }
}
 

protected boolean onSongMenuItemClick(MenuItem item) {
    if (image != null && image.getVisibility() == View.VISIBLE) {
        switch (item.getItemId()) {
            case R.id.action_go_to_album:
                Pair[] albumPairs = new Pair[]{
                        Pair.create(image, activity.getResources().getString(R.string.transition_album_art))
                };
                NavigationUtil.goToAlbum(activity, getSong().albumId, albumPairs);
                return true;
        }
    }
    return false;
}
 

public static void show(@NonNull Activity activity, @NonNull View avatarView,
                        @NonNull View titleView, @NonNull Issue issue) {
    Intent intent = new Intent(activity, IssueDetailActivity.class);
    Pair<View, String> avatarPair = Pair.create(avatarView, "userAvatar");
    Pair<View, String> titlePair = Pair.create(titleView, "issueTitle");
    ActivityOptionsCompat optionsCompat = ActivityOptionsCompat
            .makeSceneTransitionAnimation(activity, avatarPair, titlePair);
    intent.putExtras(BundleHelper.builder().put("issue", issue).build());
    activity.startActivity(intent, optionsCompat.toBundle());
}
 

private Pair<EventGroup, Integer> findGroup(long timeMillis) {
    int position = 0;
    // TODO improve searching
    for (int i = 0; i < mEventGroups.size(); i++) {
        EventGroup group = mEventGroups.get(i);
        if (group.mTimeMillis == timeMillis) {
            return Pair.create(group, position);
        } else {
            position += group.itemCount() + 1;
        }
    }
    return null;
}
 

@Override
public void onClick(View v) {
    if (isInQuickSelectMode()) {
        toggleChecked(getAdapterPosition());
    } else {
        Pair[] artistPairs = new Pair[]{
                Pair.create(image,
                        activity.getResources().getString(R.string.transition_artist_image)
                )};
        NavigationUtil.goToArtist(activity, dataSet.get(getAdapterPosition()).getId(), artistPairs);
    }
}
 

@Override
public void onClick(View v) {
    if (isInQuickSelectMode()) {
        toggleChecked(getAdapterPosition());
    } else {
        Pair[] albumPairs = new Pair[]{
                Pair.create(image,
                        activity.getResources().getString(R.string.transition_album_art)
                )};
        NavigationUtil.goToAlbum(activity, dataSet.get(getAdapterPosition()).getId(), albumPairs);
    }
}
 

@Override
protected boolean onSongMenuItemClick(MenuItem item) {
    if (item.getItemId() == R.id.action_go_to_album) {
        Pair[] albumPairs = new Pair[]{
                Pair.create(image, activity.getString(R.string.transition_album_art))
        };
        NavigationUtil.goToAlbum(activity, dataSet.get(getAdapterPosition()).albumId, albumPairs);
        return true;
    }
    return super.onSongMenuItemClick(item);
}
 

@Override
public void start(Bundle invocationData, IJobCallback callback) throws RemoteException {
  startArguments = Pair.create(invocationData, callback);
  if (startException.isPresent()) {
    throw startException.get();
  }
}
 

@Override
public void itemClicked(View view, MediaItem item, int position) {
    String transitionName = getString(R.string.transition_image);
    VideoListAdapter.ViewHolder viewHolder =
            (VideoListAdapter.ViewHolder) mRecyclerView.findViewHolderForPosition(position);
    Pair<View, String> imagePair = Pair
            .create((View) viewHolder.getImageView(), transitionName);
    ActivityOptionsCompat options = ActivityOptionsCompat
            .makeSceneTransitionAnimation(getActivity(), imagePair);

    Intent intent = new Intent(getActivity(), LocalPlayerActivity.class);
    intent.putExtra("media", item.toBundle());
    intent.putExtra("shouldStart", false);
    ActivityCompat.startActivity(getActivity(), intent, options.toBundle());
}
 

private Bundle getOptionsBundle(final Activity activity, final View[] sharedElements) {
    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) return null;
    if (sharedElements == null) return null;
    int len = sharedElements.length;
    if (len <= 0) return null;
    @SuppressWarnings("unchecked")
    Pair<View, String>[] pairs = new Pair[len];
    for (int i = 0; i < len; i++) {
        pairs[i] = Pair.create(sharedElements[i], sharedElements[i].getTransitionName());
    }
    return ActivityOptionsCompat.makeSceneTransitionAnimation(activity, pairs).toBundle();
}
 

public static Pair<SceneLifecycleManager<NavigationScene>, NavigationScene> createFromInitSceneLifecycleManager(final Scene rootScene) {
    ActivityController<TestActivity> controller = Robolectric.buildActivity(TestActivity.class).create().start().resume();
    TestActivity testActivity = controller.get();
    NavigationScene navigationScene = new NavigationScene();
    NavigationSceneOptions options = new NavigationSceneOptions(rootScene.getClass());
    navigationScene.setArguments(options.toBundle());

    Scope.RootScopeFactory rootScopeFactory = new Scope.RootScopeFactory() {
        @Override
        public Scope getRootScope() {
            return Scope.DEFAULT_ROOT_SCOPE_FACTORY.getRootScope();
        }
    };

    SceneComponentFactory sceneComponentFactory = new SceneComponentFactory() {
        @Override
        public Scene instantiateScene(ClassLoader cl, String className, Bundle bundle) {
            if (className.equals(rootScene.getClass().getName())) {
                return rootScene;
            }
            return null;
        }
    };

    navigationScene.setDefaultNavigationAnimationExecutor(new NoAnimationExecutor());
    navigationScene.setRootSceneComponentFactory(sceneComponentFactory);

    SceneLifecycleManager<NavigationScene> sceneLifecycleManager = new SceneLifecycleManager<>();
    sceneLifecycleManager.onActivityCreated(testActivity, testActivity.mFrameLayout,
            navigationScene, rootScopeFactory,
            false, null);
    return Pair.create(sceneLifecycleManager, navigationScene);
}
 

public static Pair<Integer, Double> findMax(Matrix matrix) {
    final int index = argmax(matrix);

    return Pair.create(index, matrix.getArray()[index]);
}
 

@Nullable
protected Pair<Integer, Fragment> popFragmentFromBackStack() {
  Pair<Integer, BackStackEntry> pair = backStackManager.pop();
  return pair != null ? Pair.create(pair.first, pair.second.toFragment(this)) : null;
}
 

public void getTransactionResult(final String resultId, final int attemptNumber) {
    if (attemptNumber < 60) {
        final Activity activity = this;
        // GET THE TRANSACTION RESULT
        JsonObjectRequest jsonObjectRequest = new JsonObjectRequest(Request.Method.GET, BACKEND_URL + "/api/results/" + resultId, null,
                new Response.Listener<JSONObject>() {
                    @Override
                    public void onResponse(JSONObject response) {
                        BackendResult backendResult = gson.fromJson(response.toString(), BackendResult.class);

                        // Check status of queued request
                        if (backendResult.status.equals("pending")) {
                            // if it is still pending, check again
                            new Handler().postDelayed(new Runnable() {
                                @Override
                                public void run() {
                                    getTransactionResult(resultId,attemptNumber + 1);
                                }
                            },500);
                        } else if (backendResult.status.equals("done")) {
                            // when blockchain is done processing the request, get the contract model and start activity
                            ResultOfMakePurchase resultOfMakePurchase = gson.fromJson(backendResult.result, ResultOfMakePurchase.class);
                            ContractModel contractModel = gson.fromJson(resultOfMakePurchase.result.results.payload, ContractModel.class);

                            // start activity of contract details
                            Intent intent = new Intent(getApplicationContext(), ContractDetails.class);
                            intent.putExtra("CONTRACT_JSON", new Gson().toJson(contractModel, ContractModel.class));

                            Pair<View, String> pair1 = Pair.create(findViewById(R.id.productImageInQuantity),"productImage");
                            ActivityOptionsCompat options = ActivityOptionsCompat.makeSceneTransitionAnimation(activity, pair1);

                            activity.startActivity(intent,options.toBundle());
                        } else {
                            Log.d(TAG, "Response is: " + response.toString());
                        }
                    }
                }, new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {
                Log.d(TAG, "That didn't work!");
            }
        });
        queue.add(jsonObjectRequest);
    }
}