Come inviare oggetti tramite bundle

https://stackoverflow.com/questions/4249897

27-09-2019
|

Domanda

Devo passare un riferimento alla classe che esegue la maggior parte della mia elaborazione tramite un bundle.

Il problema è che non ha nulla a che fare con intenti o contesti e ha una grande quantità di oggetti non primitivi.Come posso impacchettare la classe in un parcelable/serializable e passarla a a startActivityForResult?

Soluzione

Per capire quale strada prendere richiede di rispondere non solo domanda chiave di CommonsWare di "perché", ma anche la questione del "che cosa?" stai passando.

La realtà è che l'unica cosa che può passare attraverso fasci sono dati semplici - tutto il resto si basa su interpretazioni di ciò che i mezzi di dati o punti. Non si può letteralmente passa un oggetto, ma cosa si può fare è una delle tre cose:

1) È possibile rompere l'oggetto verso il basso per la sua costituiscono dei dati, e se ciò che è all'altro capo ha conoscenza lo stesso tipo di oggetto, è possibile assemblare un clone dai dati serializzati. Ecco come la maggior parte dei tipi comuni passano attraverso fasci.

2) È possibile passare un manico opaco. Se si passa all'interno dello stesso contesto (anche se ci si potrebbe chiedere perché preoccuparsi) che sarà una maniglia è possibile richiamare o dereference. Ma se si passa attraverso Binder in un contesto diverso è valore letterale sarà un numero arbitrario (infatti, contano questi numeri arbitrari in sequenza dalla partenza). Non si può fare altro che tenere traccia di esso, fino a quando si passa indietro al contesto originario che causerà Binder per trasformare di nuovo nel manico originale, rendendolo utile di nuovo.

3) è possibile passare una maniglia magica, come ad esempio un descrittore di file o il riferimento a certi oggetti OS / piattaforma, e se si imposta le bandiere giuste Binder creerà una punta clone per la stessa risorsa per il destinatario, che può effettivamente essere utilizzato sull'altra estremità. Ma questo funziona solo per pochissimi tipi di oggetti.

Molto probabilmente, si sta passando sia la classe solo così l'altra estremità può tenere traccia di esso e dare di nuovo a voi più tardi, o si sta passando ad un contesto in cui un clone può essere creata con dati costituenti serializzati .. . oppure si sta cercando di fare qualcosa che proprio non sta andando al lavoro e avete bisogno di ripensare l'intero approccio.

Altri suggerimenti

È inoltre possibile utilizzare GSON per convertire un oggetto in un JSONObject e trasmetterla fascio. Per me è stato il modo più elegante che ho trovato per fare questo. Non ho ancora testato come influenza le prestazioni.

In attività iniziale

Intent activity = new Intent(MyActivity.this,NextActivity.class);
activity.putExtra("myObject", new Gson().toJson(myobject));
startActivity(activity);

In Avanti Attività

String jsonMyObject;
Bundle extras = getIntent().getExtras();
if (extras != null) {
   jsonMyObject = extras.getString("myObject");
}
MyObject myObject = new Gson().fromJson(jsonMyObject, MyObject.class);

Parcelable interfaccia è un buon modo per passare un oggetto con un intento.

Come posso fare oggetti mia abitudine Parcelable? è un buon risposta su come uso Parcelable

Il funzionario Google Docs anche includere un esempio

Si potrebbe utilizzare il globale stato dell'applicazione .

Aggiornamento:

Personalizza e quindi aggiungere questo al vostro AndroidManifest.xml:

<application android:label="@string/app_name" android:debuggable="true" android:name=".CustomApplication"

E poi hanno una classe del progetto in questo modo:

package com.example;

import android.app.Application;

public class CustomApplication extends Application {
    public int someVariable = -1;
}

E poiché " Vi si può accedere tramite getApplication () da qualsiasi attività o servizio", si utilizza in questo modo:

CustomApplication application = (CustomApplication)getApplication();
application.someVariable = 123;

La speranza che aiuta.

È possibile anche fare i vostri oggetti Serializable e utilizzare il bundle del < a href = "http://developer.android.com/reference/android/os/Bundle.html#getSerializable%28java.lang.String%29" rel = "noreferrer"> getSerializable e putSerializable metodi "noreferrer" .

Possibile soluzione:

Bundle bundle = new Bundle();
bundle.putSerializable("key", new CustomObject());

Classe CustomObject:

class CustomObject implements Serializable{
 private SubCustomObject1 sc1;
 private SubCustomObject2 sc2;
}

Subcustom oggetti:

class SubCustomObject1 implements Serializable{ }

class SubCustomObject2  implements Serializable{ }

Un altro modo per inviare oggetti tramite fascio è quello di utilizzare bundle.putByteArray
Codice di esempio

public class DataBean implements Serializable {
private Date currentTime;

public setDate() {
    currentTime = Calendar.getInstance().getTime();
 }

public Date getCurrentTime() {
    return currentTime;
 }
}

put oggetto di bean di dati in a Bundle:

class FirstClass{
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
//Your code...

//When you want to start new Activity...
Intent dataIntent =new Intent(FirstClass.this, SecondClass.class);
            Bundle dataBundle=new Bundle();
            DataBean dataObj=new DataBean();
            dataObj.setDate();
            try {
                dataBundle.putByteArray("Obj_byte_array", object2Bytes(dataObj));

            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();

            }

            dataIntent.putExtras(dataBundle);

            startActivity(dataIntent);
}

Conversione degli oggetti di array di byte

/**
 * Converting objects to byte arrays
 */
static public byte[] object2Bytes( Object o ) throws IOException {
      ByteArrayOutputStream baos = new ByteArrayOutputStream();
      ObjectOutputStream oos = new ObjectOutputStream( baos );
      oos.writeObject( o );
      return baos.toByteArray();
    }

tornare Oggetto da Bundle:

class SecondClass{
DataBean dataBean;
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
//Your code...

//Get Info from Bundle...
    Bundle infoBundle=getIntent().getExtras();
    try {
        dataBean = (DataBean)bytes2Object(infoBundle.getByteArray("Obj_byte_array"));
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (ClassNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}

metodo per ottenere gli oggetti da array di byte:

/**
 * Converting byte arrays to objects
 */
static public Object bytes2Object( byte raw[] )
        throws IOException, ClassNotFoundException {
      ByteArrayInputStream bais = new ByteArrayInputStream( raw );
      ObjectInputStream ois = new ObjectInputStream( bais );
      Object o = ois.readObject();
      return o;
    }

Spero che questo vi aiuterà ad altri compagni.

1.A molto diretto e facile da usare ad esempio, fanno oggetto da passare implementare Serializable.

class Object implements Serializable{
    String firstName;
   String lastName;
}

oggetto 2.pass in bundle

Bundle bundle = new Bundle();
Object Object = new Object();
bundle.putSerializable("object", object);

3.Get passato oggetto dal fascio come Serializable poi colato per oggetto.

Object object = (Object) getArguments().getSerializable("object");

Questa è una risposta molto tardivo alla mia domanda, ma continuo a ricevere attenzione, quindi mi sento devo affrontarlo. La maggior parte di queste risposte sono corrette e gestire il lavoro perfettamente. Tuttavia, dipende dalle esigenze dell'applicazione. Questa risposta sarà utilizzato per descrivere due soluzioni a questo problema.

Application

Il primo è il Applicazione , come è stato il più parla di risposta Qui. L'applicazione è un oggetto buono a posto le entità che hanno bisogno di un riferimento a un contesto. Un `ServerSocket` senza dubbio avrebbe bisogno di un contesto (per il file I / O o semplice` ListAdapter` aggiornamenti). Io, personalmente, preferisco questo percorso. Ho come l'applicazione di, sono utili per il recupero contesto (perché possono essere fatti statici e non probabile causa una perdita di memoria) e hanno un semplice ciclo di vita.

servizio

Il Service` è secondo. Un Service`is in realtà la scelta migliore per il mio `problema taormina che è quali servizi sono progettati per fare:

A Service is an application component that can perform long-running operations in
the background and does not provide a user interface.

Servizi sono ordinate in quanto hanno un ciclo di vita più definito che è più facile da controllare. Inoltre, se necessario, i servizi possono eseguire esternamente dell'applicazione (ie. All'avvio). Questo può essere necessario per alcune applicazioni o semplicemente una caratteristica accurata.

Questa non era una descrizione completa di entrambi, ma ho lasciato link ai documenti per chi vuole indagare di più. Nel complesso il Service è il meglio per l'istanza di cui avevo bisogno -. L'esecuzione di un ServerSocket al mio dispositivo SPP

mi sono imbattuto in questa domanda quando ero alla ricerca di un modo per passare un oggetto Date. Nel mio caso, come è stato suggerito tra le risposte, ho usato Bundle.putSerializable (), ma che non avrebbe funzionato per una cosa complessa come descritto DataManager nel post originale.

Il mio suggerimento che darà un risultato molto simile a mettere detto DataManager nell'applicazione o ne fanno un Singleton è quello di utilizzare Dependency Injection e si legano il DataManager a un ambito Singleton e iniettare il DataManager ovunque sia necessario. Non solo si ottiene il vantaggio di una maggiore controllabilità, ma potrai anche ottenere codice più pulito senza tutte piastra caldaia "passando le dipendenze in giro tra le classi e le attività" di codice. (Robo) Guice è molto facile da lavorare e la nuova dagger sguardi quadro promettente pure.

un altro modo semplice per passare l'oggetto utilizzando un bundle:

nell'oggetto classe, crea un elenco statico o un'altra struttura dati con una chiave
quando crei l'oggetto inseriscilo nella struttura lista/dati con la chiave (es.il timestamp lungo al momento della creazione dell'oggetto)
creare il metodo getObject statico (chiave lunga) per ottenere l'oggetto dall'elenco
nel bundle passa la chiave, così potrai ottenere l'oggetto successivamente da un altro punto del codice

Autorizzato sotto: CC-BY-SA insieme a attribuzione

Non affiliato a StackOverflow