Cómo leer el código fuente del framework de Android

Primero mire el método setVideoEncoder en MediaRecorder.java:

/**

* Configure el codificador de video para grabar. Si no se llama a este método

*, el archivo de salida no contendrá la pista de vídeo. Llámame después

* setOutputFormat() y antes de prepare().

*

* @param video_encoder El codificador de vídeo que se utilizará.

* @Throw IllegalStateException (si se llama antes)

* Después de setOutputFormat() o prepare()

* @Ver video multimedia de Android. codificador

*/

codificador de video set void nativo público (int video _ codificador)

lanza IllegalStateException123456789101112

Este es un método local. De acuerdo con las reglas de JNI, debemos ir a Android_media_media recorder.CPP para ver la implementación de este método:

Static void

Android_media_media recorder_setvideo encoder(JNIEnv * env, jobject thiz, jint ve )

{

ALOGV("setvideoencer(% d)",ve);

if(ve <VIDEO_ENCODER_DEFAULT || ve >=video_encoder_list_end){

jniThrowException(env, "Java/lang/IllegalArgumentException", "Codificador de vídeo no válido");

return;

}

sp <MediaRecorder>mr = getMediaRecorder(env,thiz);

Llamada a Process Media Recorder(env,Mr-> setVideoEncoder(ve), "java/lang/RuntimeException", "setVideoEncoder falló.");

}1234567891011

La clave son las dos últimas frases. sp es un puntero en Android y no se puede ver ~ por lo que las dos últimas oraciones significan llamar al método setVideoEncoder de la capa nativa MediaRecorder.

Vaya a MediaRecorder.cpp para ver el método setVideoEncoder:

status _ t media recorder::setvideo encoder(int ve)

{

ALOGV("setvideoencer(% d)",ve);

if (mMediaRecorder == NULL) {

ALOGE("La grabadora multimedia no se ha inicializado");

Devuelve operación_inválida;

}

if (!mIsVideoSourceSet) {

ALOGE("Intente configurar la codificación de vídeo sin configurar primero el fuente de vídeo ");

Devuelve invalid_operative;

}

if(misvideencoderset){

ALOGE("El codificador de vídeo se ha configurado ");

devuelve operación_inválida;

}

if (!(mCurrentState & ampmedia_recorder_datasource_configured) ){

ALOGE("setVideoEncoder fue llamado en estado no válido (%d)", mCurrentState);

Devuelve invalid_operative;

}

status_t ret = mMediaRecorder-> setvideo encoder(ve) ;

if (ok! = ret) {

ALOGV(" setvideodencoder falló: % d ", ret);

mCurrentState = MEDIA _ RECORDER _ ERROR

devolver ret

}

mIsVideoEncoderSet = true

p>

Devolver ret

} 1234567891011121314151617181920212223242526272829

El MMediaReorder aquí está definido en MediaRecorder.h:

sp & ltIMediaRecorder & gtmMediaRecorder1

Se puede ver que es una variable de tipo IMediaRecorder y pertenece al tipo de interfaz. Eche un vistazo a la definición de su interfaz.

En IMediaRecorder.h:

Clase IMediaRecorder: Interfaz pública

{

Pública:

DECLARE _ META _ INTERFACE(grabadora multimedia) ;

Estado virtual_t configurar cámara(const sp<hardware::ICamera>&camera,

const sp<ICameraRecordingProxy>& proxy)=0;

Estado virtual_t setPreviewSurface(const sp<IGraphicBufferProducer>& superficie)=0;

Estado virtual_t setVideoSource(int vs)=0;

Estado virtual_t setAudioSource(int as)= 0;

Estado virtual_t setOutputFormat( int of)= 0;

Codificador virtual state_t setvideo(int ve) = 0;

Codificador virtual status_t setaudio(int AE)= 0;

Virtual status_t setOutputFile(int fd, int64_t offset, int 64_t length)= 0;

Virtual state_t setVideoSize(int width, int height)= 0;

Virtual state_t setVideoFrameRate(int frames_per_segundo) = 0;

Parámetros de configuración de estado virtual (const String8 & ampparams) = 0;

Estado virtual _ t establece el oyente (const sp & lt; IMediaRecorderClient & gt& amplistener) = 0;

Estado virtual _ t establece el nombre del cliente (cadena constante 16 y nombre del cliente) = 0

Estado virtual_t listo() = 0

Estado virtual; _ t obtener amplitud máxima (int * max) = 0;

Estado virtual_t start()= 0;

Estado virtual_t stop()= 0;

Estado virtual _ t reset() = 0

Estado virtual _ t pausa() =

Estado virtual _ t resume() = 0; >Virtual status_t init()= 0;

virtual status_t close()= 0;

virtual status_t release()= 0;

virtual status_t setInputSurface( const sp<IGraphicBufferConsumer>& Surface)=0;

virtual sp<IGraphicBufferProducer>querysurfacediasource()=0;

};

// -

BnMediaRecorder clase: público BnInterface & ltIMediaRecorder & gt

{

Público:

Contrato de estado virtual (uint32_t

Código,

constPackage y Empresa de envío. data,

Pack * respuesta,

uint 32 _ t flags = 0

};

Na ~crítico Ha llegado un paso. Básicamente los he perseguido hasta aquí antes, e incluso si termino de perseguirlos, no sé cómo seguir persiguiéndolos. Más tarde, leí sobre Binder y aprendí sobre el papel de BnInterface. La interfaz bn es una parte clave de Binder. No entraré en detalles aquí. Solo recuerde, lo que vamos a buscar a continuación es BnMediaRecorder.

Busque globalmente ":public BnMediaRecorder", es decir, busque su clase de implementación y busque la siguiente definición en MediaRecorderClient.h:

Clase MediaRecorderClient:public BnMediaRecorder

{

Clase notificador de muerte de servicio:público I carpeta::destinatario de muerte

{

Público:

Notificador de muerte de servicio (

servicio const sp & ltIBinder & gt& amp,

const sp & ltIMediaRecorderClient & gt& amp oyente,

int cual

virtual ~ ServiceDeathNotifier();

La carpeta de vacío virtual murió (const WP<IBinder>&who);

Privada:

int mWhich

sp & ltIBinder & gtmService

wp & ltIMediaRecorderClient & gtmListener

};

Público:

estado virtual_t configurar cámara (const sp<. Hardware::ICamera>&Camera,

const sp<ICameraRecordingProxy>&Proxy);

Estado virtual_t setPreviewSurface(const sp& lt; IGraphicBufferProducer>& superficie);

Estado virtual_t setVideoSource(int vs );

Virtual state_t setAudioSource(int as);

Virtual state_t setOutputFormat(int of);

Virtual state_t setvideo codificador(int ve);

Codificador virtual state_t setaudio(int AE);

virtual status_t setOutputFile(int fd, int64_t offset,

int64_t length);

virtual status_t setVideoSize(int width, int height);

Virtual state_t setVideoFrameRate(int frames_per_segundo);

Parámetros de configuración de estado virtual (const String8 y ampparams);

Virtual state_t setListener(

p>

const sp & ltIMediaRecorderClient & gt& oyente);

Virtual status_t establece el nombre del cliente (const string 16 & nombre del cliente);

Estado virtual _t preparar();

Estado virtual_t obtener amplitud máxima(int * max);

Estado virtual_t inicio();

Estado virtual _t detener ();

Estado virtual_ t reset();

Estado virtual_ t pausa(

);

Estado virtual_t reanudar();

Estado virtual_t init();

Estado virtual_t cerrar();

Estado virtual_t release();

Volcado de estado virtual(int fd, const Vector & ltString16 >& apargs);

Estado virtual_t setInputSurface(const sp & lt; IGraphicBufferConsumer & gt & Surface);

SP virtual & ltIGraphicBufferProducer & gtquerysurfacediasource();

Privado:

Clase amiga MediaPlayerService // constructor privado de acceso usado

MediaRecorderClient(

const sp & ltMediaPlayerService & gt& amp service,

pid_t pid,

const string 16 & amp;opPackageName);

virtual ~ MediaRecorderClient();

carpeta sp & ltI::destinatario de muerte & gt;mCameraDeathListener

carpeta sp & ltI::destinatario de muerte & gt; pid _ t mPid

Bloqueo mutex;

MediaRecorderBase * mRecorder

sp & ltMediaPlayerService & gtmMediaPlayerService

};1234567891011121314151617181920212223242526272829303132333435363 738 394041424344454647484950515253545556575 85960616263646566

Entonces vayamos a MediaRecorderClient.cpp y echemos un vistazo:

status _ t MediaRecorderClient::setvideo encoder(int ve)

p>

{

ALOGV("setvideoencer(% d)",ve);

Mutex::Autolock lock(mLock);

if (mRecorder == NULL) {

ALOGE("Grabadora no inicializada");

Devolver NO _ INIT

}

Devolver mRecorder->setvideo encoder((video _ encoder)ve);

}12345678910

El mRecorder aquí está definido en MediaRecorderClient.h:

MediaRecorderBase * mRecorder1

Vamos , sigamos buscando ":public MediaRecorderBase" y lo encontramos en StagefrightRecorder.h, luego vayamos a StagefrightRecorder.cpp y echemos un vistazo~

status _ t stageforshrecorder::setvideo encoder(video _ enco

der ve){

ALOGV(" setvideodencoder:% d ", ve

if(ve <video_encoder_default||

ve & gt=video_encoder_list_end ){

ALOGE("Codificador de vídeo no válido: %d ", ve);

Devuelve un valor incorrecto;

}

mVideoEncoder = ve

Regresar OK;

}123456789101112

Está bien, esto terminó ~ Finalmente encontraremos que la implementación de la interfaz en MediaRecorder básicamente caerá en este StagefrightRecorder .cpp.