¿Cómo se define parcelable del tipo de interfaz en el archivo .aidl?

Question

Tengo un archivo .aidl que define un único parcelable de un tipo de interfaz, digamos

parcelable MyInterface; 

medio de las cuales MyInterface es una interfaz Java declarados en MyInterface.java que amplía la interfaz parcelable. El mecanismo parcelable de Android requiere que defina un CREADOR estático en la clase parcelable. Pero, ¿cómo puedo hacer esto para una interfaz ya que la clase de interfaz no conoce la implementación concreta y por lo tanto no puede implementar el método createFromParcel()?

¿Cómo decidirá el tiempo de ejecución de Android qué CREADOR (desde qué subclase) llamar? ¿Es incluso imposible utilizar un tipo de interfaz en un archivo .aidl?

Answer 1

1. sobre la interfaz de uso en el archivo AIDL: No creo que haya nada hay que nos impida hacerlo. Porque "MyInterface parcelable"; realmente no genera nada en la carpeta gen, solo es necesario para la firma de funciones de cualquier interfaz AIDL usando este tipo de Mi Interfaz.

2. CREADOR Debes agregar la definición del creador para todas tus clases. Implementa android.os.Parcelable.

Answer 2

implementar el parcelable sobre AIDL

Primer paso: - Crear un archivo .aidl diferente que será utilizado para definir la clase de Estudiantes (clase parcelable).

 (Student.aidl) 
     package com.aidl; 
     parcelable Student; 

escribimos esto porque helpl puede detectar la clase de Estudiante.

Segundo paso: - ahora tiene que definir una clase java con nombre student e implementar la interfaz parcable en esta clase. La interfaz parcable tiene dos métodos abstractos que debe implementar en su clase de estudiante.

import android.os.Parcel; 
    import android.os.Parcelable; 
    public class Student implements Parcelable { 
      public String name; 
      public String father_name; 
      public Student(Parcel source) 
      { 
          name = source.readString(); 
          father_name = source.readString(); 
      } 
      public Student() 
      {} 
      public void setName(String name) 
      { 
          this.name = name; 
      } 
      public void setFatherName(String father_name) 
      { 
          this.father_name = father_name; 
      } 

// métodos de interfaz parcable

  @Override 
      public int describeContents() { 
          // TODO Auto-generated method stub 
          return 0; 
      } 
      @Override 
      public void writeToParcel(Parcel dest, int flags) { 
          // TODO Auto-generated method stub 
          dest.writeString(name); 
          dest.writeString(father_name); 

      } 

en cualquier clase que está implementando parcelable tienen que proporcionar campo CREATOR. El tipo de CREATOR debe ser Parcelable.Creator. Aquí en lugar de T escribimos el nombre de nuestra clase, por ej. Estudiante. CREATOR se usa durante el desmantelamiento del objeto.

Tiene dos métodos -

1-T createFromParcel(Parcel parcel) :This method is called when UnMarshalling happen 
    during receiving the data. Keep care that we receive the data member in same sequence 
    as we write in writeToPacel(). Here we create a constructor in which we demarshalling 
    the data. 
2-NewArray(int size) : Here we just create an array of given size and return. 


public static final Parcelable.Creator<Student> CREATOR = new Parcelable.Creator<Student>() { 
       @Override 
       public Student createFromParcel(Parcel source) { 
              // TODO Auto-generated method stub 
              return new Student(source); 
       } 
       @Override 
       public Student[] newArray(int size) { 
              // TODO Auto-generated method stub 
              return new Student[size]; 
       } 
      }; 

para obtener más información: Check Here

Answer 3

me encontré con escenario similar, y quería compartir lo que hice. Tenía la siguiente interfaz principal de aidl que contiene otra interfaz dentro de ella.

//ICounterAidlInterface.aidl 

import path.to.aidldirectory.CounterListener 

interface ICounterAidlInterface { 
    int getCounter(); 
    void setCounterListener(CounterListener listener); 
} 

No olvide la importación.

La pregunta es cómo representar este nuevo tipo: CounterListener.Como el CounterListener es una interfaz, no es necesario marcarlo como parcelable.

También necesita crear otro archivo aidl para el CounterListener. Por lo tanto, he creado otro archivo AIDL:

//CounterListener.aidl 
interface CounterListener{ 
    void newData(int data); 
} 

Espero que esto ayude :)