Bitmap.Config.ARGB_8888,Bitmap.Config.RGB_565, Bitmap.Config.ARGB_4444 : Bitmap « 2D Graphics « Android

Home
Android
1.2D Graphics
2.Animation
3.Core Class
4.Database
5.Date Type
6.Development
7.File
8.Game
9.Hardware
10.Media
11.Network
12.Security
13.UI
14.User Event
Android » 2D Graphics » Bitmap 
Bitmap.Config.ARGB_8888,Bitmap.Config.RGB_565, Bitmap.Config.ARGB_4444
    
/*
 * Copyright (C) 2007 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package app.test;

import java.io.ByteArrayOutputStream;

import android.app.Activity;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Picture;
import android.graphics.Rect;
import android.graphics.drawable.Drawable;
import android.os.Bundle;
import android.util.AttributeSet;
import android.view.View;
import android.view.ViewGroup;
import android.view.ViewParent;

public class Test extends GraphicsActivity {

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(new SampleView(this));
  }

  private static final int WIDTH = 50;
  private static final int HEIGHT = 50;
  private static final int STRIDE = 64// must be >= WIDTH

  private static int[] createColors() {
    int[] colors = new int[STRIDE * HEIGHT];
    for (int y = 0; y < HEIGHT; y++) {
      for (int x = 0; x < WIDTH; x++) {
        int r = x * 255 (WIDTH - 1);
        int g = y * 255 (HEIGHT - 1);
        int b = 255 - Math.min(r, g);
        int a = Math.max(r, g);
        colors[y * STRIDE + x(a << 24(r << 16(g << 8| b;
      }
    }
    return colors;
  }

  private static class SampleView extends View {
    private Bitmap[] mBitmaps;
    private Bitmap[] mJPEG;
    private Bitmap[] mPNG;
    private int[] mColors;
    private Paint mPaint;

    private static Bitmap codec(Bitmap src, Bitmap.CompressFormat format,
        int quality) {
      ByteArrayOutputStream os = new ByteArrayOutputStream();
      src.compress(format, quality, os);

      byte[] array = os.toByteArray();
      return BitmapFactory.decodeByteArray(array, 0, array.length);
    }

    public SampleView(Context context) {
      super(context);
      setFocusable(true);

      mColors = createColors();
      int[] colors = mColors;

      mBitmaps = new Bitmap[6];
      // these three are initialized with colors[]
      mBitmaps[0= Bitmap.createBitmap(colors, 0, STRIDE, WIDTH, HEIGHT,
          Bitmap.Config.ARGB_8888);
      mBitmaps[1= Bitmap.createBitmap(colors, 0, STRIDE, WIDTH, HEIGHT,
          Bitmap.Config.RGB_565);
      mBitmaps[2= Bitmap.createBitmap(colors, 0, STRIDE, WIDTH, HEIGHT,
          Bitmap.Config.ARGB_4444);

      // these three will have their colors set later
      mBitmaps[3= Bitmap.createBitmap(WIDTH, HEIGHT,
          Bitmap.Config.ARGB_8888);
      mBitmaps[4= Bitmap.createBitmap(WIDTH, HEIGHT,
          Bitmap.Config.RGB_565);
      mBitmaps[5= Bitmap.createBitmap(WIDTH, HEIGHT,
          Bitmap.Config.ARGB_4444);
      for (int i = 3; i <= 5; i++) {
        mBitmaps[i].setPixels(colors, 0, STRIDE, 00, WIDTH, HEIGHT);
      }

      mPaint = new Paint();
      mPaint.setDither(true);

      // now encode/decode using JPEG and PNG
      mJPEG = new Bitmap[mBitmaps.length];
      mPNG = new Bitmap[mBitmaps.length];
      for (int i = 0; i < mBitmaps.length; i++) {
        mJPEG[i= codec(mBitmaps[i], Bitmap.CompressFormat.JPEG, 80);
        mPNG[i= codec(mBitmaps[i], Bitmap.CompressFormat.PNG, 0);
      }
    }

    @Override
    protected void onDraw(Canvas canvas) {
      canvas.drawColor(Color.WHITE);

      for (int i = 0; i < mBitmaps.length; i++) {
        canvas.drawBitmap(mBitmaps[i]00null);
        canvas.drawBitmap(mJPEG[i]800null);
        canvas.drawBitmap(mPNG[i]1600null);
        canvas.translate(0, mBitmaps[i].getHeight());
      }

      // draw the color array directly, w/o craeting a bitmap object
      canvas.drawBitmap(mColors, 0, STRIDE, 00, WIDTH, HEIGHT, true,
          null);
      canvas.translate(0, HEIGHT);
      canvas.drawBitmap(mColors, 0, STRIDE, 00, WIDTH, HEIGHT, false,
          mPaint);
    }
  }
}

class GraphicsActivity extends Activity {
  // set to true to test Picture
  private static final boolean TEST_PICTURE = false;

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
  }

  @Override
  public void setContentView(View view) {
    if (TEST_PICTURE) {
      ViewGroup vg = new PictureLayout(this);
      vg.addView(view);
      view = vg;
    }

    super.setContentView(view);
  }
}

class PictureLayout extends ViewGroup {
  private final Picture mPicture = new Picture();

  public PictureLayout(Context context) {
    super(context);
  }

  public PictureLayout(Context context, AttributeSet attrs) {
    super(context, attrs);
  }

  @Override
  public void addView(View child) {
    if (getChildCount() 1) {
      throw new IllegalStateException(
          "PictureLayout can host only one direct child");
    }

    super.addView(child);
  }

  @Override
  public void addView(View child, int index) {
    if (getChildCount() 1) {
      throw new IllegalStateException(
          "PictureLayout can host only one direct child");
    }

    super.addView(child, index);
  }

  @Override
  public void addView(View child, LayoutParams params) {
    if (getChildCount() 1) {
      throw new IllegalStateException(
          "PictureLayout can host only one direct child");
    }

    super.addView(child, params);
  }

  @Override
  public void addView(View child, int index, LayoutParams params) {
    if (getChildCount() 1) {
      throw new IllegalStateException(
          "PictureLayout can host only one direct child");
    }

    super.addView(child, index, params);
  }

  @Override
  protected LayoutParams generateDefaultLayoutParams() {
    return new LayoutParams(LayoutParams.MATCH_PARENT,
        LayoutParams.MATCH_PARENT);
  }

  @Override
  protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    final int count = getChildCount();

    int maxHeight = 0;
    int maxWidth = 0;

    for (int i = 0; i < count; i++) {
      final View child = getChildAt(i);
      if (child.getVisibility() != GONE) {
        measureChild(child, widthMeasureSpec, heightMeasureSpec);
      }
    }

    maxWidth += getPaddingLeft() + getPaddingRight();
    maxHeight += getPaddingTop() + getPaddingBottom();

    Drawable drawable = getBackground();
    if (drawable != null) {
      maxHeight = Math.max(maxHeight, drawable.getMinimumHeight());
      maxWidth = Math.max(maxWidth, drawable.getMinimumWidth());
    }

    setMeasuredDimension(resolveSize(maxWidth, widthMeasureSpec),
        resolveSize(maxHeight, heightMeasureSpec));
  }

  private void drawPict(Canvas canvas, int x, int y, int w, int h, float sx,
      float sy) {
    canvas.save();
    canvas.translate(x, y);
    canvas.clipRect(00, w, h);
    canvas.scale(0.5f0.5f);
    canvas.scale(sx, sy, w, h);
    canvas.drawPicture(mPicture);
    canvas.restore();
  }

  @Override
  protected void dispatchDraw(Canvas canvas) {
    super.dispatchDraw(mPicture.beginRecording(getWidth(), getHeight()));
    mPicture.endRecording();

    int x = getWidth() 2;
    int y = getHeight() 2;

    if (false) {
      canvas.drawPicture(mPicture);
    else {
      drawPict(canvas, 00, x, y, 11);
      drawPict(canvas, x, 0, x, y, -11);
      drawPict(canvas, 0, y, x, y, 1, -1);
      drawPict(canvas, x, y, x, y, -1, -1);
    }
  }

  @Override
  public ViewParent invalidateChildInParent(int[] location, Rect dirty) {
    location[0= getLeft();
    location[1= getTop();
    dirty.set(00, getWidth(), getHeight());
    return getParent();
  }

  @Override
  protected void onLayout(boolean changed, int l, int t, int r, int b) {
    final int count = super.getChildCount();

    for (int i = 0; i < count; i++) {
      final View child = getChildAt(i);
      if (child.getVisibility() != GONE) {
        final int childLeft = getPaddingLeft();
        final int childTop = getPaddingTop();
        child.layout(childLeft, childTop,
            childLeft + child.getMeasuredWidth(),
            childTop + child.getMeasuredHeight());

      }
    }
  }
}

   
    
    
    
  
Related examples in the same category
1.Using BitmapFactory to decode Resource
2.Capture and save to Bitmap
3.Bitmap size
4.Draw Bitmap on Canvas
5.Bitmap.createBitmap
6.Draw Bitmap on Canvas with Matrix
7.Create a Bitmap for drawing
8.Load Bitmap and Draw
9.Bitmap and RenderScript
10.Alpha Bitmap
11.Load Bitmap from InputStream
12.Bitmap Decode
13.Bitmap Mesh
14.Bitmap Pixels
15.Create a Bitmap
16.Purgeable Bitmap
17.Create a bitmap with a circle
18.This activity demonstrates various ways density can cause the scaling of bitmaps and drawables.
19.Get the current system wallpaper, modifies it and sets the modified bitmap as system wallpaper.
20.Bitmap cache by WeakHashMap
21.Memory Cache for Bitmap
22.Load Bitmap from resource
23.Crop Bitmap
24.Create Scaled Bitmap
25.downloading a bitmap image from http and setting it to given image view asynchronously
26.Get Bitmap From Local Path
27.Get Bitmap From Bytes
28.Compress Bitmap
29.Resize Bitmap
30.captures given view and converts it to a bitmap
31.Save Bitmap and BitmapFactory.decodeFile
32.Generate a blurred bitmap from given one
33.Get Bitmap From Name
34.Load Bitmap with Context
35.Load Bitmap from InputStream
36.Get Bitmap from Url with HttpURLConnection
37.Rotate Bitmap
38.Get Texture From Bitmap Resource and BitmapFactory.decodeStream
39.Drawable to Bitmap
40.Save Bitmap to and load from External Storage
41.Get Image Bitmap From Url
42.Scale Bitmap
43.Unscaled Bitmap Loader
44.Save Bitmap to External Storage Directory
45.Compress and save Bitmap image
46.Bitmap downloading, processing
47.Rotate a Bitmap
48.Save/load Bitmap
49.Find components of color of the bitmap at x, y.
50.get Bitmap From Url
51.Draw Bitmap and Drawable
52.Rotate, transform Bitmap
53.Rotate specified Bitmap by a random angle. Scales the specified Bitmap to fit within the specified dimensions.
54.Loads a bitmap from the specified url.
55.Bitmap Refelection
56.Create a transparent bitmap from an existing bitmap by replacing certain color with transparent
57.Get Texture From Bitmap Resource
58.Bitmap Resize
59.bitmap to Byte
60.Flip Image
61.Scale an Image
62.Translate Image
63.Image Mirror
64.Moving an Image with Motion
65.Draw on Picture and save
66.Calculate optimal preview size from given parameters
67.generate Mipmaps For Bound Texture
68.Provides common tools for manipulating Bitmap objects.
java2s.com  | Contact Us | Privacy Policy
Copyright 2009 - 12 Demo Source and Support. All rights reserved.
All other trademarks are property of their respective owners.