Document

A operação da interface writeToParcel é o serializador. Ele é chamado em um objeto quando é necessário serializar esse mesmo objeto em um Parcel. O trabalho do serializador é escrever tudo que é necessário para reconstruir o estado do objeto ao Parcel transmitido. Isso significa expressar o estado do objeto em termos de, basicamente, cinco tipos de dados primitivos do Java:

byte,
double,
int,
float,
long.

Além desses, o tipo abstrato String também pode ser utilizado.

public class SimpleParcelable implements Parcelable {

public enum State {
BEGIN, MIDDLE, END
};

private static final Map<State, String> marshalState;

static {
Map<State, String> m = new HashMap<State, String>();
m.put(State.BEGIN, "begin");
m.put(State.MIDDLE, "middle");
m.put(State.END, "end");

marshalState = Collections.unmodifiableMap(m);
}

private State state;
private Date date;

private long dateToLong() {
return (date == null) ? -1 : date.getTime();
}

private String stateToString() {
return (state == null) ? "" : marshalState.get(state);
}

@Override
public void writeToParcel(Parcel dest, int flags) {
// traduz um date para um long
dest.writeLong(dateToLong());

// traduz o state para String
dest.writeString(stateToString());
}

public State getState() {
return state;
}

public void setState(State state) {
this.state = state;
}

public Date getDate() {
return date;
}

public void setDate(Date date) {
this.date = date;
}

}

Evidentemente, a implementação exata de writeToParcel dependerá do conteúdo do objeto sendo serializado. Nesse caso, o objeto SimpleParcelable tem duas informações de estado e escreve ambas no Parcel transmitido.

A escolha de uma representação para a maioria dos tipos simples de dados não exigirá nada além de um pouco de engenhosidade. O date, neste exemplo, é facilmente representado pelo tempo transcorrido. Não se esqueça, entretanto, de considerar alterações futuras nos dados, quando estiver escolhendo a representação serializada.

Certamente teria sido mais fácil, nesse exemplo, representar state como um int cujo valor poderia ser obtido chamando-se state.ordinal(). Ao fazê-lo, entretanto, tornaríamos muito mais difícil a compatibilidade futura do objeto. Suponha que se torne necessário em algum momento, adicionar um novo estado, State.INIT, antes de State.BEGIN. Essa alteração trivial faria com que novas versões do objeto se tornassem completamente incompatíveis com as versões anteriores.