programacion - manual de android en pdf

pasar una imagen de mapa de bits de una actividad a otra

Question

En mi aplicación, no muestro imágenes de la galería desde donde, tan pronto como selecciono una imagen, la imagen debe enviarse a la nueva actividad donde la imagen seleccionada se establecerá como fondo. Sin embargo, puedo obtener las imágenes de la galería, pero tan pronto como selecciono uno la aplicación se cuelga. Gracias de antemano

Actividad-1 (Las imágenes se muestran en la galería y la imagen seleccionada se envía a la nueva actividad)

public class Gallery extends Activity {

private static int RESULT_LOAD_IMAGE = 1;

    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.gallery);

        Button buttonLoadImage = (Button) findViewById(R.id.buttonLoadPicture);


        buttonLoadImage.setOnClickListener(new View.OnClickListener() {

            public void onClick(View arg0) {

                Intent i = new Intent(Intent.ACTION_PICK,android.provider.MediaStore.Images.Media.EXTERNAL_CONTENT_URI);

                startActivityForResult(i, RESULT_LOAD_IMAGE);
            }
        });
    }



    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);

        if (requestCode == RESULT_LOAD_IMAGE && resultCode == RESULT_OK && null != data) {






            Uri contentUri = data.getData();          
            String[] proj = { MediaStore.Images.Media.DATA };         
            Cursor cursor = managedQuery(contentUri, proj, null, null, null);         
            int column_index = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATA);         
            cursor.moveToFirst();         
            String tmppath = cursor.getString(column_index);           
            Bitmap croppedImage = BitmapFactory.decodeFile(tmppath);


            // Bitmap croppedImage = BitmapFactory.decodeFile(croppedImage);
            Intent intent = new Intent(Gallery.this,GesturesActivity.class);
            intent.putExtra("bmp",croppedImage);
            startActivity(intent);

            Log.v("sending image","sending image");


        }


    }
}

Actividad-1 (XML)

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:background="@drawable/background"
    >
    <ImageView
            android:id="@+id/imgView"
            android:layout_width="fill_parent"
            android:layout_weight="1" android:layout_height="wrap_content"></ImageView>
    <Button 
            android:layout_height="wrap_content" 
            android:text="Load Picture" 
            android:layout_width="wrap_content" 
            android:id="@+id/buttonLoadPicture" 
            android:layout_weight="0" 
            android:layout_gravity="center"></Button>
</LinearLayout>

Activity-2 (La actividad donde la imagen seleccionada debe establecerse como imagen de fondo de la pantalla)

  public class GesturesActivity extends Activity {


        private final int MENU_CAMERA = Menu.FIRST;


        public void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            requestWindowFeature(Window.FEATURE_NO_TITLE);


            Bitmap bmp = (Bitmap)this.getIntent().getParcelableExtra("bmp");
            BitmapDrawable background = new BitmapDrawable(bmp);
            getWindow().setBackgroundDrawable(background);  //background image of the screen



            Bitmap bitmap = BitmapFactory.decodeResource(getResources(), R.drawable.advert);
            View view = new SandboxView(this, bitmap);

            setContentView(view);
        }



        public boolean onPrepareOptionsMenu(Menu menu) {
            menu.clear();

                menu.add(0, 11, 0, "Take Snapshot");

                    return super.onPrepareOptionsMenu(menu);
        }


        public boolean onOptionsItemSelected(MenuItem item) {

            return super.onOptionsItemSelected(item);
        }



    }

Answer 1

Al usar esto, puede pasar el mapa de bits a otra actividad.

Si está utilizando dibujable, primero conviértalo en dibujable en mapa de bits.

Bitmap bitmap = ((BitmapDrawable)d).getBitmap();

Para pasar ese mapa de bits a otra actividad usando intención, use este fragmento de código a continuación.

intent.putExtra("Bitmap", bitmap);

Y para buscar esa intención de mapa de bits en otra actividad usa esto

Bitmap bitmap = (Bitmap)this.getIntent().getParcelableExtra("Bitmap");

Siga este enlace para obtener más detalles.

Answer 2

Bitmap implementa Parcelable , por lo que siempre podría pasarlo en el intento. prueba el siguiente código:

Primera actividad.

Intent mIntent = new Intent(this, ActivityTwo.class);
mIntent.putExtra("bmp_img", bmp);

para obtener resultados en la actividad objetivo, intente:

Segunda actividad.

Bitmap mBitmap = (Bitmap) intent.getParcelableExtra("bmp_img");

siempre usa getParcelableExtra ("clave") para obtener el Bitmap que pasa en Activity.

Answer 3

Como está recuperando la imagen de la Galería, ¿por qué no pasar el ID a la siguiente actividad y recuperar la imagen en esa actividad en lugar de pasar la imagen? Esto te ayudará con la memoria y el rendimiento.

Answer 4

Creo que puedes hacerlo definiendo tu mapa de bits como estático y llamando a classname.bitmap puedes obtener el mapa de bits ... y establecerlo como fondo en la siguiente actividad

Answer 5

Hay 3 soluciones para resolver este problema.

1) Primero, convierta la imagen en una matriz de bytes y luego pase a Intent y en la siguiente actividad obtenga la matriz de bytes de Bundle y la convierte en Image (Bitmap) y configure en ImageView.

Convertir mapa de bits a matriz de bytes: -

Bitmap bmp = BitmapFactory.decodeResource(getResources(), R.drawable.ic_launcher);
ByteArrayOutputStream stream = new ByteArrayOutputStream();
bmp.compress(Bitmap.CompressFormat.PNG, 100, stream);
byte[] byteArray = stream.toByteArray();

Pasar matriz de bytes en la intención: -

Intent intent = new Intent(this, NextActivity.class);
intent.putExtra("picture", byteArray);
startActivity(intent);

Obtener matriz de bytes de paquete y convertir en imagen de mapa de bits: -

Bundle extras = getIntent().getExtras();
byte[] byteArray = extras.getByteArray("picture");

Bitmap bmp = BitmapFactory.decodeByteArray(byteArray, 0, byteArray.length);
ImageView image = (ImageView) findViewById(R.id.imageView1);

image.setImageBitmap(bmp);

2) Primero guarde la imagen en la tarjeta SD y en la siguiente actividad configure esta imagen en ImageView.

3) Pase Bitmap a Intent y obtenga bitmap en la siguiente actividad del bundle, pero el problema es si su tamaño de Bitmap / Image es grande en ese momento en que la imagen no se carga en la siguiente actividad.

Answer 6

He encontrado que la forma más fácil (pero definitivamente no la más elegante) es usar un miembro de clase estático. p.ej:

class PassedData
{
    public Bitmap bm1, bm2, etc;

    private PassedData current;

    public static PassedData getCurrent() {return current;}

    public PassedData()
    {
        current = this;
    }
}

Luego, cada actividad puede hacer referencia a PassedData.getCurrent ().

Answer 7

IGP lo resumió claramente, pero en mi opinión, la forma más eficiente de hacerlo es pasar el URI de la imagen a la siguiente actividad, en lugar del propio mapa de bits. De hecho, no estoy seguro de si es posible pasar mapas de bits completos (o convertidos, ByteArrays) de datos de una actividad a otra usando Intentos: creo que hay un límite en cuanto a la cantidad de datos que un paquete puede contener.

En su lugar, pase la referencia que está utilizando para mostrar la imagen en la primera actividad. ¿Supongo que estás usando algún tipo de carga lenta? Si no, te recomiendo que lo hagas. De esta manera, simplemente puede volver a consultar para el mapa de bits a través del URI.

Sin embargo, puedo obtener las imágenes de la galería, pero tan pronto como selecciono una, la aplicación falla

Todavía estoy desconcertado sobre cómo estos tipos de problemas llegan a SO. Revisa los registros, tal vez puedas resolverlo por tu cuenta.

Answer 8

Actividad

Pasar un mapa de bits entre Activites

Intent intent = new Intent(this, Activity.class);
intent.putExtra("bitmap", bitmap);

Y en la clase de Actividad

Bitmap bitmap = getIntent().getParcelableExtra("bitmap");

Fragmento

Pasar un mapa de bits entre Fragmentos

SecondFragment fragment = new SecondFragment();
Bundle bundle = new Bundle();
bundle.putParcelable("bitmap", bitmap);
fragment.setArguments(bundle);

Para recibir dentro de SecondFragment

Bitmap bitmap = getArguments().getParcelable("bitmap");

Si obtiene una transacción de encuadernación fallida, esto significa que está excediendo el búfer de transacción del encuadernador transfiriendo un elemento grande de una actividad a otra.

Entonces, en ese caso, debe comprimir el mapa de bits como una matriz de bytes y luego descomprimirlo en otra actividad , como esta

En la primera actividad

Intent intent = new Intent(this, SecondActivity.class);

ByteArrayOutputStream stream = new ByteArrayOutputStream();
bitmap.compress(Bitmap.CompressFormat.JPG, 100, stream);
byte[] bytes = stream.toByteArray(); 
intent.putExtra("bitmapbytes",bytes);

Y en la segunda actividad

byte[] bytes = getIntent().getByteArrayExtra("bitmapbytes");
Bitmap bmp = BitmapFactory.decodeByteArray(bytes, 0, bytes.length);