Android中如何实现相互关联的ImageView联动移动与工位驻留控制？

Got it, let's figure out how to add that required pause between your ImageView movements for your production flow Android app. You've already nailed the first part of getting the two views to move between workstations—now let's add the delay cleanly with two solid approaches:

Method 1: Kotlin Coroutines (Modern, Recommended) #

Coroutines make async delays and UI sequencing super straightforward without blocking the main thread. Here's how to plug this into your existing movement logic:

First, let's assume you have a function that handles moving an ImageView to a target workstation. We'll add a completion callback, then use a coroutine to pause before triggering the next step:

// Inside your Activity/Fragment
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch
import androidx.lifecycle.lifecycleScope // Use this instead of GlobalScope to avoid leaks

fun startProductionSequence() {
    // Step 1: Move first ImageView to workstation 2, second to workstation 1
    moveToWorkstation(imageView1, workstation2X, workstation2Y) {
        // Callback runs when movement finishes
        lifecycleScope.launch {
            // Pause for your specified duration (e.g., 3000ms = 3 seconds)
            delay(3000)
            
            // Switch back to main thread for next UI operation
            runOnUiThread {
                moveToWorkstation(imageView2, workstation1X, workstation1Y) {
                    // Add any follow-up logic here (e.g., next production step)
                }
            }
        }
    }
}

// Reusable function to animate ImageView movement
private fun moveToWorkstation(view: ImageView, targetX: Float, targetY: Float, onComplete: () -> Unit) {
    val animatorX = ValueAnimator.ofFloat(view.x, targetX)
    val animatorY = ValueAnimator.ofFloat(view.y, targetY)
    
    animatorX.addUpdateListener { view.x = it.animatedValue as Float }
    animatorY.addUpdateListener { view.y = it.animatedValue as Float }
    
    val animSet = AnimatorSet().apply {
        playTogether(animatorX, animatorY)
        duration = 1000 // Adjust movement speed as needed
        addListener(object : Animator.AnimatorListener {
            override fun onAnimationEnd(animation: Animator?) = onComplete.invoke()
            override fun onAnimationStart(animation: Animator?) {}
            override fun onAnimationCancel(animation: Animator?) {}
            override fun onAnimationRepeat(animation: Animator?) {}
        })
    }
    animSet.start()
}

Why this works: #

• lifecycleScope ensures coroutines are canceled when your Activity/Fragment is destroyed, preventing memory leaks
• delay() is non-blocking, so your app stays responsive during the pause
• The completion callback guarantees we only start the delay after the movement animation finishes

Method 2: Handler (Legacy/Java-Compatible) #

If you're working with Java or prefer a more traditional approach, a Handler gets the job done too:

// Inside your Activity
private Handler movementHandler = new Handler();

public void startProductionSequence() {
    // Initial movement: ImageView1 to workstation 2, ImageView2 to workstation 1
    moveToWorkstation(imageView1, workstation2X, workstation2Y, () -> {
        // Post a delayed runnable to trigger the next step after 3 seconds
        movementHandler.postDelayed(() -> {
            moveToWorkstation(imageView2, workstation1X, workstation1Y, () -> {
                // Add follow-up logic here
            });
        }, 3000); // Delay in milliseconds
    });
}

// Reusable movement function for Java
private void moveToWorkstation(ImageView view, float targetX, float targetY, Runnable onComplete) {
    ValueAnimator animatorX = ValueAnimator.ofFloat(view.getX(), targetX);
    ValueAnimator animatorY = ValueAnimator.ofFloat(view.getY(), targetY);
    
    animatorX.addUpdateListener(anim -> view.setX((float) anim.getAnimatedValue()));
    animatorY.addUpdateListener(anim -> view.setY((float) anim.getAnimatedValue()));
    
    AnimatorSet animSet = new AnimatorSet();
    animSet.playTogether(animatorX, animatorY);
    animSet.setDuration(1000);
    animSet.addListener(new Animator.AnimatorListener() {
        @Override
        public void onAnimationEnd(Animator animation) {
            onComplete.run();
        }
        @Override public void onAnimationStart(Animator animation) {}
        @Override public void onAnimationCancel(Animator animation) {}
        @Override public void onAnimationRepeat(Animator animation) {}
    });
    animSet.start();
}

Important Reminder: #

• Always clean up the Handler when your Activity/Fragment is destroyed to avoid leaks:

  @Override
  protected void onDestroy() {
      super.onDestroy();
      movementHandler.removeCallbacksAndMessages(null);
  }
  

Quick Pro Tips: #

• If you have a long sequence of movements and pauses, consider using a flow or state machine to avoid callback hell (especially with Coroutines)
• Adjust the delay() value and animation duration to match your production flow's timing requirements
• Test on different devices to ensure the delay and movement feel smooth

内容的提问来源于stack exchange，提问作者Nadja