android - vectoriales - Obtener tamaño de vista de imagen para la creación de mapas de bits

tipos de imagenes vectoriales

Question

Soy un programador con un fondo de Windows y soy nuevo en Java y Android.

Quiero crear un widget (no una aplicación) que muestra un gráfico.

después de una larga investigación, sé que puedo hacer esto con Canvas, imageviews y Bitmaps.

El lienzo en el que pinto debe ser el mismo que el Tamaño del widget.

así que la pregunta es: ¿cómo puedo saber el tamaño del widget (o tamaño de vista de imagen) para poder suministrarlo a la función?

Bitmap.createBitmap (width_xx, height_yy, Config.ARGB_8888);

Fragmento de código: en el método de ejecución del temporizador:

@Override
    public void run() {
        Bitmap bitmap = Bitmap.createBitmap(??, ??, Config.ARGB_8888);
        Canvas canvas = new Canvas(bitmap);

        //create new paint  
        Paint p = new Paint();
        p.setAntiAlias(true);
        p.setStrokeWidth(1);

        //draw circle
        //here i can use the width and height to scale the circle
        canvas.drawCircle(50, 50, 7, p);
        remoteViews.setImageViewBitmap(R.id.imageView, bitmap);

Answer 1

Actualmente estoy usando esto, espero que ayude

private void run() {

    int width = 400, height = 400;

    Bitmap bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
    Canvas c = new Canvas(bitmap);

    Paint p = new Paint();
    p.setColor(Color.WHITE);
    p.setStyle(Paint.Style.STROKE);
    p.setStrokeWidth(1);
    p.setAntiAlias(true);

    c.drawCircle(width/2, height/2, radius, p);

    remoteViews.setImageViewBitmap(R.id.imageView, bitmap);

    ComponentName clockWidget = new ComponentName(context,
    Clock_22_analog.class);
    AppWidgetManager appWidgetManager = AppWidgetManager
    .getInstance(context);
    appWidgetManager.updateAppWidget(clockWidget, remoteViews);
}

Answer 2

Aquí hay unos tutoriales que debe seguir, todo está claramente definido para: Desarrollar widgets de la pantalla de inicio de Android

Answer 3

Como dijo Julian, puedes obtenerlos así con un mapa de bits de tu imagen.

int width = bitmap.getWidth();
int height = bitmap.getHeight();

Answer 4

De lo que he aprendido, solo puedes calcular las dimensiones del widget en Android 4.1+. Cuando esté en una API más baja, tendrá que usar dimensiones estáticas. Acerca de las dimensiones del widget: Pautas de diseño de widgets de aplicaciones

int w = DEFAULT_WIDTH, h = DEFAULT_HEIGHT;

if ( Build.VERSION.SDK_INT >= 16 ) {
    Bundle options = appWidgetManager.getAppWidgetOptions(widgetId);

    int maxW = options.getInt(AppWidgetManager.OPTION_APPWIDGET_MAX_WIDTH);
    int maxH = options.getInt(AppWidgetManager.OPTION_APPWIDGET_MAX_HEIGHT);

    int minW = options.getInt(AppWidgetManager.OPTION_APPWIDGET_MIN_WIDTH);
    int minH = options.getInt(AppWidgetManager.OPTION_APPWIDGET_MIN_HEIGHT);

    if ( context.getResources().getConfiguration().orientation == Configuration.ORIENTATION_LANDSCAPE ) {
        w = maxW;
        h = minH;
    } else {
        w = minW;
        h = maxH;
    }
}

Answer 5

Echa un vistazo al método:

public void onAppWidgetOptionsChanged (Context context, AppWidgetManager appWidgetManager, int appWidgetId, Bundle newOptions)

Se llamará cada vez que inicie / cambie el tamaño del widget.

Obtener el ancho / alto del widget se puede hacer de la siguiente manera:

newOptions.getInt(AppWidgetManager.OPTION_APPWIDGET_MIN_WIDTH)
newOptions.getInt(AppWidgetManager.OPTION_APPWIDGET_MAX_WIDTH)
newOptions.getInt(AppWidgetManager.OPTION_APPWIDGET_MIN_HEIGHT)
newOptions.getInt(AppWidgetManager.OPTION_APPWIDGET_MAX_HEIGHT)

Déjame saber si esto responde a tu pregunta.

Answer 6

No he trabajado en Widgets, pero tengo algo de experiencia en obtener el tamaño de ImageView.

Aquí hay un código que utilizo:

public class ViewSizes {
    public int width;
    public int height;

    public boolean isEmpty() {
        boolean result = false;
        if (0 >= width || 0 >= height) {
            result = true;
        }
        return result;
    }
}

Eso es sólo una clase ficticia que contiene los parámetros de tamaño.

public static ViewSizes getSizes(View view) {
        ViewSizes sizes = new ViewSizes();
        sizes.width = view.getWidth();
        sizes.height = view.getHeight();

        if (sizes.isEmpty()) {
            LayoutParams params = view.getLayoutParams();
            if (null != params) {
                int widthSpec = View.MeasureSpec.makeMeasureSpec(params.width, View.MeasureSpec.AT_MOST);
                int heightSpec = View.MeasureSpec.makeMeasureSpec(params.height, View.MeasureSpec.AT_MOST);
                view.measure(widthSpec, heightSpec);
            }

            sizes.width = view.getMeasuredWidth();
            sizes.height = view.getMeasuredHeight();
        }

        return sizes;
    }

Este método calcula el ancho forzando un ciclo de medición si aún no ha ocurrido.

public static boolean loadPhoto(ImageView view, String url, float aspectRatio) {
    boolean processed = false;
    ViewSizes sizes = ViewsUtils.getSizes(view);

    if (!sizes.isEmpty()) {
        int width = sizes.width - 2;
        int height = sizes.height - 2;
        if (ASPECT_RATIO_UNDEFINED != aspectRatio) {
            if (height * aspectRatio > width) {
                height = (int) (width / aspectRatio);
            } else if (height * aspectRatio < width) {
                width = (int) (height * aspectRatio);
            }
        }

        // Do you bitmap processing here

        processed = true;
    }

    return processed;
}

Este es probablemente inútil para ti. Doy solo un ejemplo: tengo un ImageView y un url de imagen, que deben ser parametrizados con imagen y altura.

public class PhotoLayoutListener implements OnGlobalLayoutListener {
    private ImageView view;
    private String url;
    private float aspectRatio;


    public PhotoLayoutListener(ImageView view, String url, float aspectRatio) {
        this.view = view;
        this.url = url;
        this.aspectRatio = aspectRatio;
    }

    boolean handled = false;
    @Override
    public void onGlobalLayout() {
        if (!handled) {
            PhotoUtils.loadPhoto(view, url, aspectRatio);   
            handled = true;
        }

        ViewTreeObserver viewTreeObserver = view.getViewTreeObserver();
        if (viewTreeObserver.isAlive()) {
            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.JELLY_BEAN) {
                removeLayoutListenerPre16(viewTreeObserver, this);
            } else {
                removeLayoutListenerPost16(viewTreeObserver, this);
            }
        }
    }

    @SuppressWarnings("deprecation")
    private void removeLayoutListenerPre16(ViewTreeObserver observer, OnGlobalLayoutListener listener){
        observer.removeGlobalOnLayoutListener(listener);
    }

    @TargetApi(Build.VERSION_CODES.JELLY_BEAN)
    private void removeLayoutListenerPost16(ViewTreeObserver observer, OnGlobalLayoutListener listener){
        observer.removeOnGlobalLayoutListener(listener);
    }
}

Esto es solo un detector de diseño. Quiero procesar la carga de la imagen una vez que la fase de diseño haya finalizado.

public static void setImage(ImageView view, String url, boolean forceLayoutLoading, float aspectRatio) {
    if (null != view && null != url) {
        final ViewTreeObserver viewTreeObserver = view.getViewTreeObserver();

        if (forceLayoutLoading || !PhotoUtils.loadPhoto(view, url, aspectRatio)) {
            if (viewTreeObserver.isAlive()) {
                viewTreeObserver.addOnGlobalLayoutListener(new PhotoLayoutListener(view, url, aspectRatio));
            }
        }
    }
}

Este es el método que realmente llamo. Le doy la vista y url. Los métodos se ocupan de la carga: si puede determinar el tamaño de la vista, comienza a cargarse inmediatamente. De lo contrario, solo asigna un detector de diseño e inicia el proceso de carga una vez que el diseño finaliza.

Podría eliminar algunos parámetros: forceLoading / aspectRatio debería ser irrelevante para usted. Después de eso, cambie el método PhotoUtils.loadPhoto para crear el mapa de bits con el ancho / alto que ha calculado.

Answer 7

puedes usar esto

Bitmap image1, image2;

Bitmap bitmap = Bitmap.createBitmap(image1.getWidth(), image1.getHeight(), Bitmap.Config.ARGB_8888);
Canvas c = new Canvas(bitmap);

Espero que ayude. :)

Answer 8

u puede crear un widget personalizado ... y establecer el tamaño de wight en su método onMeasure () ... y también guardar el tamaño en ese momento para que pueda usarlo más para la creación de imágenes ... Saltar