Как сделать эффект увеличения изображения в студии Android?

Question

Я попробовал this учебник, чтобы применить эффект масштабирования к моему ImageView, но когда я его компилирую, он не масштабируется всегда.

Answer 1

Вы хотите, чтобы стиль масштабирования.

паста follwing код в папке аниматора с имя_узла

<set xmlns:android="http://schemas.android.com/apk/res/android" > 

      <objectAnimator 
       android:duration="1000" 
       android:interpolator="@android:interpolator/accelerate_decelerate" 
       android:propertyName="scaleY" 
       android:valueFrom="1" 
       android:valueTo="1.5" 
       android:repeatCount="infinite" 
       android:repeatMode="reverse" 
       /> 

      <objectAnimator 
       android:duration="1000" 
       android:interpolator="@android:interpolator/accelerate_decelerate" 
       android:propertyName="scaleX" 
       android:valueFrom="1" 
       android:valueTo="1.5" 
       android:repeatCount="infinite" 
       android:repeatMode="reverse" 
      /> 
    </set> 

в вашей деятельности

Animator animation = AnimatorInflater.loadAnimator(getApplicationContext(), R.animator.selectzoom);//select zoom is the file name of your animator xml file 
    animation.setTarget(imageView); 
    animation.start(); 

Попробуйте один раз надеясь, что он будет работать

Answer 2

Создать ZoomInZoomOut класс первый:

import android.app.Activity; 
import android.graphics.Matrix; 
import android.graphics.PointF; 
import android.os.Bundle; 
import android.util.FloatMath; 
import android.util.Log; 
import android.view.MotionEvent; 
import android.view.View; 
import android.view.View.OnTouchListener; 
import android.widget.ImageView; 

     public class ZoomInZoomOut extends Activity implements OnTouchListener 
    { 
     private static final String TAG = "Touch"; 
     @SuppressWarnings("unused") 
     private static final float MIN_ZOOM = 1f,MAX_ZOOM = 1f; 

     // These matrices will be used to scale points of the image 
     Matrix matrix = new Matrix(); 
     Matrix savedMatrix = new Matrix(); 

     // The 3 states (events) which the user is trying to perform 
     static final int NONE = 0; 
     static final int DRAG = 1; 
     static final int ZOOM = 2; 
     int mode = NONE; 

     // these PointF objects are used to record the point(s) the user is touching 
     PointF start = new PointF(); 
     PointF mid = new PointF(); 
     float oldDist = 1f; 

     /** Called when the activity is first created. */ 
     @Override 
     public void onCreate(Bundle savedInstanceState) 
     { 
      super.onCreate(savedInstanceState); 
      setContentView(R.layout.main); 
      ImageView view = (ImageView) findViewById(R.id.imageView); 
      view.setOnTouchListener(this); 
     } 

     @Override 
     public boolean onTouch(View v, MotionEvent event) 
     { 
      ImageView view = (ImageView) v; 
      view.setScaleType(ImageView.ScaleType.MATRIX); 
      float scale; 

      dumpEvent(event); 
      // Handle touch events here... 

      switch (event.getAction() & MotionEvent.ACTION_MASK) 
      { 
       case MotionEvent.ACTION_DOWN: // first finger down only 
                savedMatrix.set(matrix); 
                start.set(event.getX(), event.getY()); 
                Log.d(TAG, "mode=DRAG"); // write to LogCat 
                mode = DRAG; 
                break; 

       case MotionEvent.ACTION_UP: // first finger lifted 

       case MotionEvent.ACTION_POINTER_UP: // second finger lifted 

                mode = NONE; 
                Log.d(TAG, "mode=NONE"); 
                break; 

       case MotionEvent.ACTION_POINTER_DOWN: // first and second finger down 

                oldDist = spacing(event); 
                Log.d(TAG, "oldDist=" + oldDist); 
                if (oldDist > 5f) { 
                 savedMatrix.set(matrix); 
                 midPoint(mid, event); 
                 mode = ZOOM; 
                 Log.d(TAG, "mode=ZOOM"); 
                } 
                break; 

       case MotionEvent.ACTION_MOVE: 

                if (mode == DRAG) 
                { 
                 matrix.set(savedMatrix); 
                 matrix.postTranslate(event.getX() - start.x, event.getY() - start.y); // create the transformation in the matrix of points 
                } 
                else if (mode == ZOOM) 
                { 
                 // pinch zooming 
                 float newDist = spacing(event); 
                 Log.d(TAG, "newDist=" + newDist); 
                 if (newDist > 5f) 
                 { 
                  matrix.set(savedMatrix); 
                  scale = newDist/oldDist; // setting the scaling of the 
                         // matrix...if scale > 1 means 
                         // zoom in...if scale < 1 means 
                         // zoom out 
                  matrix.postScale(scale, scale, mid.x, mid.y); 
                 } 
                } 
                break; 
      } 

      view.setImageMatrix(matrix); // display the transformation on screen 

      return true; // indicate event was handled 
     } 

     /* 
     * -------------------------------------------------------------------------- 
     * Method: spacing Parameters: MotionEvent Returns: float Description: 
     * checks the spacing between the two fingers on touch 
     * ---------------------------------------------------- 
     */ 

     private float spacing(MotionEvent event) 
     { 
      float x = event.getX(0) - event.getX(1); 
      float y = event.getY(0) - event.getY(1); 
      return FloatMath.sqrt(x * x + y * y); 
     } 

     /* 
     * -------------------------------------------------------------------------- 
     * Method: midPoint Parameters: PointF object, MotionEvent Returns: void 
     * Description: calculates the midpoint between the two fingers 
     * ------------------------------------------------------------ 
     */ 

     private void midPoint(PointF point, MotionEvent event) 
     { 
      float x = event.getX(0) + event.getX(1); 
      float y = event.getY(0) + event.getY(1); 
      point.set(x/2, y/2); 
     } 

     /** Show an event in the LogCat view, for debugging */ 
     private void dumpEvent(MotionEvent event) 
     { 
      String names[] = { "DOWN", "UP", "MOVE", "CANCEL", "OUTSIDE","POINTER_DOWN", "POINTER_UP", "7?", "8?", "9?" }; 
      StringBuilder sb = new StringBuilder(); 
      int action = event.getAction(); 
      int actionCode = action & MotionEvent.ACTION_MASK; 
      sb.append("event ACTION_").append(names[actionCode]); 

      if (actionCode == MotionEvent.ACTION_POINTER_DOWN || actionCode == MotionEvent.ACTION_POINTER_UP) 
      { 
       sb.append("(pid ").append(action >> MotionEvent.ACTION_POINTER_ID_SHIFT); 
       sb.append(")"); 
      } 

      sb.append("["); 
      for (int i = 0; i < event.getPointerCount(); i++) 
      { 
       sb.append("#").append(i); 
       sb.append("(pid ").append(event.getPointerId(i)); 
       sb.append(")=").append((int) event.getX(i)); 
       sb.append(",").append((int) event.getY(i)); 
       if (i + 1 < event.getPointerCount()) 
        sb.append(";"); 
      } 

      sb.append("]"); 
      Log.d("Touch Events ---------", sb.toString()); 
     } 
    } 

Добавьте view как это в XML:

<com.abc.ZoomInZoomOut 
android:id="@+id/image" 
android:layout_width="match_parent" 
android:layout_height="match_parent"/> 

Answer 3

Google это package имя

package="it.sephiroth.android.library.imagezoom" 

затем импортировать библиотеку и создать класс в проекте

Импорт

import it.sephiroth.android.library.imagezoom.ImageViewTouch; 
import it.sephiroth.android.library.imagezoom.ImageViewTouch.OnImageViewTouchDoubleTapListener; 
import it.sephiroth.android.library.imagezoom.ImageViewTouch.OnImageViewTouchSingleTapListener; 
import it.sephiroth.android.library.imagezoom.ImageViewTouchBase.DisplayType; 
import it.sephiroth.android.library.imagezoom.ImageViewTouchBase.OnDrawableChangeListener; 

ZoomActivity Класс

public class ImageZoomActivity extends Activity { 

private static final String LOG_TAG = "image-test"; 
HorizontalListView listview1; 
ImageViewTouch mImage; 
Button mButton1; 
Button mButton2; 
CheckBox mCheckBox; 
ArrayList<ImageListModel> arryNew = new ArrayList<ImageListModel>(); 
@Override 
protected void onCreate(Bundle savedInstanceState) { 
    super.onCreate(savedInstanceState); 
    requestWindowFeature(Window.FEATURE_NO_TITLE); 
    setContentView(R.layout.zoom_in_layout);   
    arryNew = (ArrayList<ImageListModel>) getIntent().getSerializableExtra("xyz"); 
    System.out.println("size of array "+arryNew.size()); 
    /*if(arryNew.size() > 0) 
    { 
    selectRandomImage(arryNew.get(0)); 
    }*/ 
    if(arryNew == null) 
    { 

    } 
    else 
    { 
    //mImage.setImageResource(arryNew.get(0)); 
     Picasso.with(this).load(arryNew.get(0).getJpg()) 
     .placeholder(R.drawable.appicon).into(mImage); 
    } 
    listview1 = (HorizontalListView)findViewById(R.id.listview1); 
    listview1.setOnTouchListener(new OnTouchListener() { 
     float rawX; 
     int mTouchSlop = ViewConfiguration.get(getApplicationContext()) 
       .getScaledTouchSlop(); 
     @Override 
     public boolean onTouch(View v, MotionEvent event) { 
      switch (event.getActionMasked()) { 
      case MotionEvent.ACTION_DOWN: 
       v.getParent().requestDisallowInterceptTouchEvent(true); 
       rawX = event.getRawX(); 
       break; 
      case MotionEvent.ACTION_CANCEL: 
      case MotionEvent.ACTION_UP: 
       v.getParent().requestDisallowInterceptTouchEvent(false); 
       rawX = 0f; 
       break; 
      case MotionEvent.ACTION_MOVE: 
       if (Math.abs(rawX - event.getRawX()) > mTouchSlop) 
        v.getParent().requestDisallowInterceptTouchEvent(true); 
       break; 
      } 
      return false; 
     } 
    }); 
    HAdapter adapter1 = new HAdapter(arryNew); 
    listview1.setAdapter(adapter1); 
} 


@Override 
public void onContentChanged() { 
    super.onContentChanged(); 
    mImage = (ImageViewTouch) findViewById(R.id.image); 
    mImage.setDisplayType(DisplayType.FIT_IF_BIGGER);  
    mImage.setSingleTapListener(
     new OnImageViewTouchSingleTapListener() { 
      @Override 
      public void onSingleTapConfirmed() { 
       Log.d(LOG_TAG, "onSingleTapConfirmed"); 
      } 
     } 
    ); 

    mImage.setDoubleTapListener(
     new OnImageViewTouchDoubleTapListener() { 
      @Override 
      public void onDoubleTap() { 
       Log.d(LOG_TAG, "onDoubleTap"); 
      } 
     } 
    ); 

    mImage.setOnDrawableChangedListener(
     new OnDrawableChangeListener() { 
      @Override 
      public void onDrawableChanged(Drawable drawable) { 
       Log.i(LOG_TAG, "onBitmapChanged: " + drawable); 
      } 
     } 
    ); 
} 

@Override 
public void onConfigurationChanged(Configuration newConfig) { 
    super.onConfigurationChanged(newConfig); 
} 

Matrix imageMatrix; 
public void selectRandomImage(Integer arryImg) {      
      Bitmap bitmap = BitmapFactory.decodeResource(getResources(), arryImg); 
      final DisplayMetrics metrics = getResources().getDisplayMetrics();     
      int size = (int) (Math.min(metrics.widthPixels, metrics.heightPixels)/0.55); 
      if (null != bitmap) { 
       Log.d(LOG_TAG, "screen size: " + metrics.widthPixels + "x" + metrics.heightPixels); 
       Log.d(LOG_TAG, "bitmap size: " + bitmap.getWidth() + "x" + bitmap.getHeight()); 
       mImage.setOnDrawableChangedListener(
        new OnDrawableChangeListener() { 
         @Override 
         public void onDrawableChanged(final Drawable drawable) { 
          Log.v(LOG_TAG, "image scale: " + mImage.getScale() + "/" + mImage.getMinScale()); 
          Log.v(LOG_TAG, "scale type: " + mImage.getDisplayType() + "/" + mImage.getScaleType()); 
         } 
        } 
       ); 
       mImage.setImageBitmap(bitmap, null, -1, -1); 
      } else { 
       Toast.makeText(this, "Failed to load the image", Toast.LENGTH_LONG).show(); 
      }   
} 

private class HAdapter extends BaseAdapter { 
    ArrayList<ImageListModel> galleryitems = new ArrayList<ImageListModel>(); 

    public HAdapter(ArrayList<ImageListModel> arryNew) { 
     super(); 
     this.galleryitems = arryNew; 
    } 

    public int getCount() { 
     return galleryitems.size(); 
    } 

    public Object getItem(int position) { 
     return null; 
    } 

    public long getItemId(int position) { 
     return 0; 
    } 

    public View getView(final int position, View convertView, 
      ViewGroup parent) { 
     View retval = LayoutInflater.from(parent.getContext()).inflate(R.layout.custom_zoom_items, null); 
     ImageView image = (ImageView) retval.findViewById(R.id.imgItem); 

      Picasso.with(ImageZoomActivity.this).load(galleryitems.get(position).getThumb()) 
     .placeholder(R.drawable.appicon).into(image); 
     //image.setImageResource(galleryitems.get(position));   
      //Picasso.with(getApplicationContext()).load(galleryitems.get(position)).placeholder(R.drawable.appicon).into(image); 
     retval.setOnClickListener(new OnClickListener() {    
      @Override 
      public void onClick(View v) { 
       // mImage.setImageResource(arryNew.get(position)); 
        Picasso.with(ImageZoomActivity.this).load(galleryitems.get(position).getJpg()) 
       .placeholder(R.drawable.appicon).into(mImage); 
      } 
     }); 
     return retval; 
    } 
    }; 
} 

ImageListModel

import java.io.Serializable; 

@SuppressWarnings("serial") 
public class ImageListModel implements Serializable{ 
    String thumb,jpg; 

    public String getThumb() { 
    return thumb; 
} 

    public void setThumb(String thumb) { 
    this.thumb = thumb; 
} 

    public String getJpg() { 
    return jpg; 
} 

    public void setJpg(String jpg) { 
    this.jpg = jpg; 
    } 
} 

и использовать этот класс, где когда-либо вы хотите, чтобы увеличить