Ottenere dimensioni imageview per la creazione di bitmap

Question

io sono un programmatore con un background di Windows e io sono nuovo a Java e roba Android,

Voglio creare un widget (non un App) che visualizza un grafico.

dopo una lunga ricerca so che posso farlo con Canvas, immagini e bitmap.

la tela su cui dipingo deve essere uguale alla dimensione del widget.

Quindi la domanda è: come faccio a sapere il widget di dimensioni (o dimensione imageview) in modo che posso fornire alla funzione

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

frammento di codice: nel metodo run timer:

@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

Ecco un tutorial si dovrebbe andare, tutto è dato chiaramente: Developing Android Home Screen Widgets

Answer 2

come Julian ha detto, è possibile ottenere in quel modo con bitmap la tua immagine

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

Answer 3

Da quello che ho imparato, puoi calcolare solo le dimensioni del widget su Android 4.1+. Quando su un'API inferiore, dovrai utilizzare le dimensioni statiche. Circa le dimensioni di widget: App Widget Design Guidelines

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 4

Attualmente sto usando questo, speriamo vi sia utile

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 5

è possibile utilizzare questo

Bitmap image1, image2; 

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

speranza che aiuta. :)

Answer 6

u possibile creare personalizzato widget..and impostare la dimensione di Wight sulla sua onMeasure() method..and anche salvare la dimensione in quel momento in modo da poter utilizzare ulteriormente per la creazione di immagini .. Hop

Answer 7

Dai un'occhiata alla metodo:

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

si chiamerà ogni volta che si avvia/ridimensionare il widget.

Come il widget di larghezza/altezza può essere fatto come segue:

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) 

fatemi sapere se questo risponde alla tua domanda.

Answer 8

Non ho lavorato su Widget, ma ho un po 'di esperienza con le dimensioni di ImageView.

Ecco il codice che uso:

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

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

Questo è solo una classe fittizia contenente i parametri di dimensione.

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; 
    } 

Questo metodo calcola la larghezza forzando un ciclo di misura se tale non è già avvenuto.

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; 
} 

Questo è probabilmente inutile per voi. Do solo un esempio: ho un ImageView e un URL immagine, che dovrebbe essere parametrizzato con immagine e altezza.

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); 
    } 
} 

Questo è solo un listener di layout: desidero elaborare il caricamento dell'immagine una volta terminata la fase di layout.

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)); 
      } 
     } 
    } 
} 

Questo è il metodo che effettivamente chiamo. Gli do la vista e l'url. I metodi si occupano del caricamento: se è in grado di determinare le dimensioni della vista, inizia a caricarsi immediatamente. Altrimenti assegna semplicemente un listener di layout e avvia il processo di caricamento una volta terminato il layout.

È possibile rimuovere alcuni parametri: forceLoading/aspectRatio dovrebbe essere irrilevante. Successivamente, modificare il metodo PhotoUtils.loadPhoto per creare la bitmap con la larghezza/altezza calcolata.