java类com.squareup.picasso.Target的实例源码

private void setBackground() {
    String s = mTeacher.getTeacher_background();
    if (FunctionHelper.isEmpty(s)) {
        img_background.setImageResource(R.drawable.background);
    } else {
        Picasso.with(mContext)
                .load("file://" + s)
                .error(R.drawable.background)
                .into(new Target() {
                    @Override
                    public void onBitmapLoaded(Bitmap bitmap, Picasso.LoadedFrom from) {
                        img_background.setImageBitmap(bitmap);
                    }

                    @Override
                    public void onBitmapFailed(Drawable errorDrawable) {
                        img_background.setImageDrawable(errorDrawable);
                        FunctionHelper.makeLToast(mContext, mResources.getString(R.string.error_load_image));
                    }

                    @Override
                    public void onPrepareLoad(Drawable placeHolderDrawable) {
                    }
                });
    }

}

public static void loadImagePreviewFromCache(Context context, SearchResultContainer container, int imageSize, Target target){
    Picasso.with(context)
            .load(container.getFirstThumbnailLink())
            .resize(imageSize, imageSize)
            .transform(new CircleTransform())
            .networkPolicy(NetworkPolicy.OFFLINE)
            .into(target);
}

public void bind(final Detection detection, final DetectionViewAdapter.Listener listener) {
    mTextView.setText(detection.getQuery());


    GradientDrawable drawable = (GradientDrawable) itemView.getBackground();
    if (detection.getContainer() != null) {
        drawable.setColor(Color.parseColor(detection.getContainer().getColor()));

        ImageLoaderHelper.loadImagePreviewFromCache(itemView.getContext(), detection.getContainer(), 80,
                new Target() {
                    @Override
                    public void onBitmapLoaded(Bitmap bitmap, Picasso.LoadedFrom from) {
                        mImageView.setImageBitmap(bitmap);
                    }

                    @Override
                    public void onBitmapFailed(Drawable errorDrawable) {

                    }

                    @Override
                    public void onPrepareLoad(Drawable placeHolderDrawable) {

                    }
                });
    } else {
        drawable.setColor(ContextCompat.getColor(itemView.getContext(), android.R.color.darker_gray));
        mImageView.setImageBitmap(null);
    }

    itemView.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View view) {
            listener.onItemClicked(detection.getQuery());
        }
    });
}

public static void display(Context context, String url, Target target){
        if(context == null){
            return;
        }
        if (TextUtils.isEmpty(url)) {
            url = "http://";
        }
        Picasso.with(context)
                .load(url)
//                .placeholder(R.drawable.icon_image_holder)
//                .error(R.drawable.icon_image_holder)
                .into(target);
    }

@Override
public ILoaderProxy saveImage(String url, final File destFile, final ICallback callback) {
    getPicasso().load(url).into(new Target() {
        @Override
        public void onBitmapLoaded(Bitmap bitmap, Picasso.LoadedFrom from) {
            FileUtil.saveBitmap(bitmap, destFile.getAbsolutePath());
            AppLike.gInstance.sendBroadcast(new Intent(Intent.ACTION_MEDIA_SCANNER_SCAN_FILE, Uri.fromFile(destFile)));
            ToastUtils.showWarnMsg("图片保存成功！");
            if (callback != null) {
                callback.onSuccess("图片保存成功");
            }
            if (bitmap != null) {
                bitmap.recycle();
            }
        }

        @Override
        public void onBitmapFailed(Drawable errorDrawable) {
            ToastUtils.showWarnMsg("图片保存失败！");
            if (callback != null) {
                callback.onFailed("图片加载失败");
            }
        }


        @Override
        public void onPrepareLoad(Drawable placeHolderDrawable) {

        }
    });
    return obtain();
}

private void initStreamerImageAndColors() {
    Target mTarget = getNightThemeTarget();
    String theme = new Settings(this).getTheme();
    if (!theme.equals(getString(R.string.night_theme_name)) && !theme.equals(getString(R.string.true_night_theme_name))) {
        mTarget = getLightThemeTarget();
    }

    mLoadingTarget = mTarget;
    Picasso.with(getBaseContext())
            .load(info.getMediumPreview())
            .into(mTarget);
}

private void loadImageFromUrl(final String url, final Callback callback) {
    final Activity activity = getCurrentActivity();
    Handler uiHandler = new Handler(Looper.getMainLooper());

    final Target target = new Target() {
        @Override
        public void onBitmapLoaded(Bitmap bitmap, Picasso.LoadedFrom from) {
            WritableMap colorMap = mapColors(bitmap);

            callback.invoke(false, colorMap);
        }

        @Override
        public void onBitmapFailed(Drawable errorDrawable) {
            callback.invoke(true, null);
        }

        @Override
        public void onPrepareLoad(Drawable placeHolderDrawable) {
        }
    };

    uiHandler.post(new Runnable() {
        @Override
        public void run() {
            Picasso
                    .with(activity.getApplicationContext())
                    .load(url)
                    .resize(200, 200)
                    .into(target);
        }
    });
}

private void createTarget() {
  target = new Target() {
    @Override
    public void onBitmapLoaded(Bitmap bitmap, LoadedFrom from) {
      materialProgressBar.setVisibility(View.INVISIBLE);
      imageView.setScaleType(ScaleType.CENTER_CROP);
      imageView.setColor(Color.TRANSPARENT);
      imageView.setImageBitmap(bitmap);
      imageView.invalidate();
      if (callBack != null) {
        callBack.onBitmapLoaded();
      }
    }

    @Override
    public void onBitmapFailed(Drawable errorDrawable) {
      materialProgressBar.setVisibility(View.INVISIBLE);
      imageView.setScaleType(ScaleType.CENTER_INSIDE);
      imageView.setImageDrawable(errorDrawable);
      if (callBack != null) {
        callBack.onBitmapFailed();
      }
    }

    @Override
    public void onPrepareLoad(Drawable placeHolderDrawable) {
      if (callBack != null) {
        callBack.onPrepareLoad();
      }
    }
  };
}

private void startImageLoading(Picasso picasso, Uri uri, int viewWidth, int rawImageWidth, int rawImageHeight) {
    L.d(LOG_TAG, "Start loading image: " + viewWidth + " " + rawImageWidth + " " + rawImageHeight);
    if(rawImageWidth > 0 && rawImageHeight > 0) {
        final Pair<Integer, Integer> scaledDimensions =
                scale(viewWidth, rawImageWidth, rawImageHeight);
        loadImage(picasso, scaledDimensions.first, scaledDimensions.second, uri);
    } else {
        picasso.load(uri).into((Target) this);
    }
}

/**
 * Loads a marker icon via URL and places it on the map at the required position.
 *
 * @param googleMap
 * @param latLng
 * @param uri
 */
private void markerWithCustomIcon(final GoogleMap googleMap, final LatLng latLng, Uri uri, final String publicId) {
    try {
        Target target = new Target() {
            @Override
            public void onBitmapLoaded(Bitmap bitmap, Picasso.LoadedFrom from) {
                MarkerOptions options = new MarkerOptions();

                options.position(latLng)
                        .icon(BitmapDescriptorFactory.fromBitmap(bitmap));

                Marker marker = googleMap.addMarker(options);

                publicMarkerIds.put(marker.getId(), publicId);

                protectedFromGarbageCollectorTargets.remove(this);
            }

            @Override
            public void onBitmapFailed(Drawable errorDrawable) {
                System.out.println("Failed to load bitmap");
                protectedFromGarbageCollectorTargets.remove(this);
            }

            @Override
            public void onPrepareLoad(Drawable placeHolderDrawable) {
                System.out.println("Preparing to load bitmap");
            }
        };

        protectedFromGarbageCollectorTargets.add(target);

        Picasso.with(reactContext)
                .load(uri)
                .into(target);
    } catch (Exception ex) {
        System.out.println(ex.getMessage());
        markerWithDefaultIcon(googleMap,latLng, publicId);
    }
}