Convert IAudioTrack to AIDL (bdc293ab) · Commits · e / os / android_frameworks_av

media/libaudioclient/AidlConversion.cpp

+18 −0

Original line number	Original line	Diff line number	Diff line
	@@ -1683,4 +1683,22 @@ legacy2aidl_NullableIMemory_SharedFileRegion(const sp<IMemory>& legacy) {
	return aidl;		return aidl;
	}		}

			ConversionResult<AudioTimestamp>
			aidl2legacy_AudioTimestamp(const media::AudioTimestampInternal& aidl) {
			AudioTimestamp legacy;
			legacy.mPosition = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.position));
			legacy.mTime.tv_sec = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.sec));
			legacy.mTime.tv_nsec = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.nsec));
			return legacy;
			}

			ConversionResult<media::AudioTimestampInternal>
			legacy2aidl_AudioTimestamp(const AudioTimestamp& legacy) {
			media::AudioTimestampInternal aidl;
			aidl.position = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.mPosition));
			aidl.sec = VALUE_OR_RETURN(convertIntegral<int64_t>(legacy.mTime.tv_sec));
			aidl.nsec = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.mTime.tv_nsec));
			return aidl;
			}

	} // namespace android		} // namespace android

media/libaudioclient/Android.bp

+3 −1

Original line number	Original line	Diff line number	Diff line
	@@ -84,7 +84,6 @@ cc_library_shared {
	"IAudioFlinger.cpp",		"IAudioFlinger.cpp",
	"IAudioPolicyService.cpp",		"IAudioPolicyService.cpp",
	"IAudioPolicyServiceClient.cpp",		"IAudioPolicyServiceClient.cpp",
	"IAudioTrack.cpp",
	"ToneGenerator.cpp",		"ToneGenerator.cpp",
	"PlayerBase.cpp",		"PlayerBase.cpp",
	"RecordingActivityTracker.cpp",		"RecordingActivityTracker.cpp",
	@@ -262,6 +261,7 @@ aidl_interface {
	"aidl/android/media/AudioPortType.aidl",		"aidl/android/media/AudioPortType.aidl",
	"aidl/android/media/AudioSourceType.aidl",		"aidl/android/media/AudioSourceType.aidl",
	"aidl/android/media/AudioStreamType.aidl",		"aidl/android/media/AudioStreamType.aidl",
			"aidl/android/media/AudioTimestampInternal.aidl",
	"aidl/android/media/AudioUsage.aidl",		"aidl/android/media/AudioUsage.aidl",
	],		],
	imports: [		imports: [
	@@ -291,10 +291,12 @@ aidl_interface {
	"aidl/android/media/CreateTrackResponse.aidl",		"aidl/android/media/CreateTrackResponse.aidl",

	"aidl/android/media/IAudioFlingerClient.aidl",		"aidl/android/media/IAudioFlingerClient.aidl",
			"aidl/android/media/IAudioTrack.aidl",
	"aidl/android/media/IAudioTrackCallback.aidl",		"aidl/android/media/IAudioTrackCallback.aidl",
	],		],
	imports: [		imports: [
	"audioclient-types-aidl",		"audioclient-types-aidl",
			"av-types-aidl",
	"shared-file-region-aidl",		"shared-file-region-aidl",
	],		],
	double_loadable: true,		double_loadable: true,

media/libaudioclient/AudioTrack.cpp

+50 −17

Original line number	Original line	Diff line number	Diff line
	@@ -784,7 +784,7 @@ status_t AudioTrack::start()
	int32_t flags = android_atomic_and(~(CBLK_STREAM_END_DONE \| CBLK_DISABLED), &mCblk->mFlags);		int32_t flags = android_atomic_and(~(CBLK_STREAM_END_DONE \| CBLK_DISABLED), &mCblk->mFlags);

	if (!(flags & CBLK_INVALID)) {		if (!(flags & CBLK_INVALID)) {
	status = mAudioTrack->start();		mAudioTrack->start(&status);
	if (status == DEAD_OBJECT) {		if (status == DEAD_OBJECT) {
	flags \|= CBLK_INVALID;		flags \|= CBLK_INVALID;
	}		}
	@@ -1477,7 +1477,8 @@ audio_port_handle_t AudioTrack::getRoutedDeviceId() {
	status_t AudioTrack::attachAuxEffect(int effectId)		status_t AudioTrack::attachAuxEffect(int effectId)
	{		{
	AutoMutex lock(mLock);		AutoMutex lock(mLock);
	status_t status = mAudioTrack->attachAuxEffect(effectId);		status_t status;
			mAudioTrack->attachAuxEffect(effectId, &status);
	if (status == NO_ERROR) {		if (status == NO_ERROR) {
	mAuxEffectId = effectId;		mAuxEffectId = effectId;
	}		}
	@@ -1607,7 +1608,7 @@ status_t AudioTrack::createTrack_l()
	input.opPackageName = mOpPackageName;		input.opPackageName = mOpPackageName;

	media::CreateTrackResponse response;		media::CreateTrackResponse response;
	sp<IAudioTrack> track = audioFlinger->createTrack(VALUE_OR_FATAL(input.toAidl()),		sp<media::IAudioTrack> track = audioFlinger->createTrack(VALUE_OR_FATAL(input.toAidl()),
	response,		response,
	&status);		&status);
	IAudioFlinger::CreateTrackOutput output = VALUE_OR_FATAL(		IAudioFlinger::CreateTrackOutput output = VALUE_OR_FATAL(
	@@ -1644,7 +1645,9 @@ status_t AudioTrack::createTrack_l()
	// so we are no longer responsible for releasing it.		// so we are no longer responsible for releasing it.

	// FIXME compare to AudioRecord		// FIXME compare to AudioRecord
	sp<IMemory> iMem = track->getCblk();		std::optional<media::SharedFileRegion> sfr;
			track->getCblk(&sfr);
			sp<IMemory> iMem = VALUE_OR_FATAL(aidl2legacy_NullableSharedFileRegion_IMemory(sfr));
	if (iMem == 0) {		if (iMem == 0) {
	ALOGE("%s(%d): Could not get control block", __func__, mPortId);		ALOGE("%s(%d): Could not get control block", __func__, mPortId);
	status = NO_INIT;		status = NO_INIT;
	@@ -1721,7 +1724,7 @@ status_t AudioTrack::createTrack_l()
	}		}
	}		}

	mAudioTrack->attachAuxEffect(mAuxEffectId);		mAudioTrack->attachAuxEffect(mAuxEffectId, &status);

	// If IAudioTrack is re-created, don't let the requested frameCount		// If IAudioTrack is re-created, don't let the requested frameCount
	// decrease. This can confuse clients that cache frameCount().		// decrease. This can confuse clients that cache frameCount().
	@@ -1965,7 +1968,8 @@ void AudioTrack::restartIfDisabled()
	ALOGW("%s(%d): releaseBuffer() track %p disabled due to previous underrun, restarting",		ALOGW("%s(%d): releaseBuffer() track %p disabled due to previous underrun, restarting",
	__func__, mPortId, this);		__func__, mPortId, this);
	// FIXME ignoring status		// FIXME ignoring status
	mAudioTrack->start();		status_t status;
			mAudioTrack->start(&status);
	}		}
	}		}

	@@ -2573,11 +2577,17 @@ retry:
	if (shaper.isStarted()) {		if (shaper.isStarted()) {
	operationToEnd->setNormalizedTime(1.f);		operationToEnd->setNormalizedTime(1.f);
	}		}
	return mAudioTrack->applyVolumeShaper(shaper.mConfiguration, operationToEnd);		media::VolumeShaperConfiguration config;
			shaper.mConfiguration->writeToParcelable(&config);
			media::VolumeShaperOperation operation;
			operationToEnd->writeToParcelable(&operation);
			status_t status;
			mAudioTrack->applyVolumeShaper(config, operation, &status);
			return status;
	});		});

	if (mState == STATE_ACTIVE) {		if (mState == STATE_ACTIVE) {
	result = mAudioTrack->start();		mAudioTrack->start(&result);
	}		}
	// server resets to zero so we offset		// server resets to zero so we offset
	mFramesWrittenServerOffset =		mFramesWrittenServerOffset =
	@@ -2647,7 +2657,9 @@ bool AudioTrack::isSampleRateSpeedAllowed_l(uint32_t sampleRate, float speed)
	status_t AudioTrack::setParameters(const String8& keyValuePairs)		status_t AudioTrack::setParameters(const String8& keyValuePairs)
	{		{
	AutoMutex lock(mLock);		AutoMutex lock(mLock);
	return mAudioTrack->setParameters(keyValuePairs);		status_t status;
			mAudioTrack->setParameters(keyValuePairs.c_str(), &status);
			return status;
	}		}

	status_t AudioTrack::selectPresentation(int presentationId, int programId)		status_t AudioTrack::selectPresentation(int presentationId, int programId)
	@@ -2659,7 +2671,9 @@ status_t AudioTrack::selectPresentation(int presentationId, int programId)
	ALOGV("%s(%d): PresentationId/ProgramId[%s]",		ALOGV("%s(%d): PresentationId/ProgramId[%s]",
	__func__, mPortId, param.toString().string());		__func__, mPortId, param.toString().string());

	return mAudioTrack->setParameters(param.toString());		status_t status;
			mAudioTrack->setParameters(param.toString().c_str(), &status);
			return status;
	}		}

	VolumeShaper::Status AudioTrack::applyVolumeShaper(		VolumeShaper::Status AudioTrack::applyVolumeShaper(
	@@ -2668,11 +2682,16 @@ VolumeShaper::Status AudioTrack::applyVolumeShaper(
	{		{
	AutoMutex lock(mLock);		AutoMutex lock(mLock);
	mVolumeHandler->setIdIfNecessary(configuration);		mVolumeHandler->setIdIfNecessary(configuration);
	VolumeShaper::Status status = mAudioTrack->applyVolumeShaper(configuration, operation);		media::VolumeShaperConfiguration config;
			configuration->writeToParcelable(&config);
			media::VolumeShaperOperation op;
			operation->writeToParcelable(&op);
			VolumeShaper::Status status;
			mAudioTrack->applyVolumeShaper(config, op, &status);

	if (status == DEAD_OBJECT) {		if (status == DEAD_OBJECT) {
	if (restoreTrack_l("applyVolumeShaper") == OK) {		if (restoreTrack_l("applyVolumeShaper") == OK) {
	status = mAudioTrack->applyVolumeShaper(configuration, operation);		mAudioTrack->applyVolumeShaper(config, op, &status);
	}		}
	}		}
	if (status >= 0) {		if (status >= 0) {
	@@ -2692,10 +2711,20 @@ VolumeShaper::Status AudioTrack::applyVolumeShaper(
	sp<VolumeShaper::State> AudioTrack::getVolumeShaperState(int id)		sp<VolumeShaper::State> AudioTrack::getVolumeShaperState(int id)
	{		{
	AutoMutex lock(mLock);		AutoMutex lock(mLock);
	sp<VolumeShaper::State> state = mAudioTrack->getVolumeShaperState(id);		std::optional<media::VolumeShaperState> vss;
			mAudioTrack->getVolumeShaperState(id, &vss);
			sp<VolumeShaper::State> state;
			if (vss.has_value()) {
			state = new VolumeShaper::State();
			state->readFromParcelable(vss.value());
			}
	if (state.get() == nullptr && (mCblk->mFlags & CBLK_INVALID) != 0) {		if (state.get() == nullptr && (mCblk->mFlags & CBLK_INVALID) != 0) {
	if (restoreTrack_l("getVolumeShaperState") == OK) {		if (restoreTrack_l("getVolumeShaperState") == OK) {
	state = mAudioTrack->getVolumeShaperState(id);		mAudioTrack->getVolumeShaperState(id, &vss);
			if (vss.has_value()) {
			state = new VolumeShaper::State();
			state->readFromParcelable(vss.value());
			}
	}		}
	}		}
	return state;		return state;
	@@ -2789,7 +2818,11 @@ status_t AudioTrack::getTimestamp_l(AudioTimestamp& timestamp)
	status_t status;		status_t status;
	if (isOffloadedOrDirect_l()) {		if (isOffloadedOrDirect_l()) {
	// use Binder to get timestamp		// use Binder to get timestamp
	status = mAudioTrack->getTimestamp(timestamp);		media::AudioTimestampInternal ts;
			mAudioTrack->getTimestamp(&ts, &status);
			if (status == OK) {
			timestamp = VALUE_OR_FATAL(aidl2legacy_AudioTimestamp(ts));
			}
	} else {		} else {
	// read timestamp from shared memory		// read timestamp from shared memory
	ExtendedTimestamp ets;		ExtendedTimestamp ets;

media/libaudioclient/IAudioFlinger.cpp

+8 −8

Original line number	Original line	Diff line number	Diff line
	@@ -256,12 +256,12 @@ public:
	{		{
	}		}

	virtual sp<IAudioTrack> createTrack(const media::CreateTrackRequest& input,		virtual sp<media::IAudioTrack> createTrack(const media::CreateTrackRequest& input,
	media::CreateTrackResponse& output,		media::CreateTrackResponse& output,
	status_t* status)		status_t* status)
	{		{
	Parcel data, reply;		Parcel data, reply;
	sp<IAudioTrack> track;		sp<media::IAudioTrack> track;
	data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());		data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());

	if (status == nullptr) {		if (status == nullptr) {
	@@ -281,7 +281,7 @@ public:
	ALOGE("createTrack returned error %d", *status);		ALOGE("createTrack returned error %d", *status);
	return track;		return track;
	}		}
	track = interface_cast<IAudioTrack>(reply.readStrongBinder());		track = interface_cast<media::IAudioTrack>(reply.readStrongBinder());
	if (track == 0) {		if (track == 0) {
	ALOGE("createTrack returned an NULL IAudioTrack with status OK");		ALOGE("createTrack returned an NULL IAudioTrack with status OK");
	*status = DEAD_OBJECT;		*status = DEAD_OBJECT;
	@@ -1199,7 +1199,7 @@ status_t BnAudioFlinger::onTransact(
	status_t status;		status_t status;
	media::CreateTrackResponse output;		media::CreateTrackResponse output;

	sp<IAudioTrack> track= createTrack(input,		sp<media::IAudioTrack> track= createTrack(input,
	output,		output,
	&status);		&status);

media/libaudioclient/IAudioTrack.cpp

deleted100644 → 0

+0 −317

Original line number	Original line	Diff line number	Diff line
	/*
	**
	** Copyright 2007, The Android Open Source Project
	**
	** Licensed under the Apache License, Version 2.0 (the "License");
	** you may not use this file except in compliance with the License.
	** You may obtain a copy of the License at
	**
	** http://www.apache.org/licenses/LICENSE-2.0
	**
	** Unless required by applicable law or agreed to in writing, software
	** distributed under the License is distributed on an "AS IS" BASIS,
	** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	** See the License for the specific language governing permissions and
	** limitations under the License.
	*/

	#define LOG_TAG "IAudioTrack"
	//#define LOG_NDEBUG 0
	#include <utils/Log.h>

	#include <stdint.h>
	#include <sys/types.h>

	#include <binder/Parcel.h>

	#include <media/IAudioTrack.h>

	namespace android {

	using media::VolumeShaper;

	enum {
	GET_CBLK = IBinder::FIRST_CALL_TRANSACTION,
	START,
	STOP,
	FLUSH,
	RESERVED, // was MUTE
	PAUSE,
	ATTACH_AUX_EFFECT,
	SET_PARAMETERS,
	SELECT_PRESENTATION,
	GET_TIMESTAMP,
	SIGNAL,
	APPLY_VOLUME_SHAPER,
	GET_VOLUME_SHAPER_STATE,
	};

	class BpAudioTrack : public BpInterface<IAudioTrack>
	{
	public:
	explicit BpAudioTrack(const sp<IBinder>& impl)
	: BpInterface<IAudioTrack>(impl)
	{
	}

	virtual sp<IMemory> getCblk() const
	{
	Parcel data, reply;
	sp<IMemory> cblk;
	data.writeInterfaceToken(IAudioTrack::getInterfaceDescriptor());
	status_t status = remote()->transact(GET_CBLK, data, &reply);
	if (status == NO_ERROR) {
	cblk = interface_cast<IMemory>(reply.readStrongBinder());
	if (cblk != 0 && cblk->unsecurePointer() == NULL) {
	cblk.clear();
	}
	}
	return cblk;
	}

	virtual status_t start()
	{
	Parcel data, reply;
	data.writeInterfaceToken(IAudioTrack::getInterfaceDescriptor());
	status_t status = remote()->transact(START, data, &reply);
	if (status == NO_ERROR) {
	status = reply.readInt32();
	} else {
	ALOGW("start() error: %s", strerror(-status));
	}
	return status;
	}

	virtual void stop()
	{
	Parcel data, reply;
	data.writeInterfaceToken(IAudioTrack::getInterfaceDescriptor());
	remote()->transact(STOP, data, &reply);
	}

	virtual void flush()
	{
	Parcel data, reply;
	data.writeInterfaceToken(IAudioTrack::getInterfaceDescriptor());
	remote()->transact(FLUSH, data, &reply);
	}

	virtual void pause()
	{
	Parcel data, reply;
	data.writeInterfaceToken(IAudioTrack::getInterfaceDescriptor());
	remote()->transact(PAUSE, data, &reply);
	}

	virtual status_t attachAuxEffect(int effectId)
	{
	Parcel data, reply;
	data.writeInterfaceToken(IAudioTrack::getInterfaceDescriptor());
	data.writeInt32(effectId);
	status_t status = remote()->transact(ATTACH_AUX_EFFECT, data, &reply);
	if (status == NO_ERROR) {
	status = reply.readInt32();
	} else {
	ALOGW("attachAuxEffect() error: %s", strerror(-status));
	}
	return status;
	}

	virtual status_t setParameters(const String8& keyValuePairs) {
	Parcel data, reply;
	data.writeInterfaceToken(IAudioTrack::getInterfaceDescriptor());
	data.writeString8(keyValuePairs);
	status_t status = remote()->transact(SET_PARAMETERS, data, &reply);
	if (status == NO_ERROR) {
	status = reply.readInt32();
	}
	return status;
	}

	/* Selects the presentation (if available) */
	virtual status_t selectPresentation(int presentationId, int programId) {
	Parcel data, reply;
	data.writeInterfaceToken(IAudioTrack::getInterfaceDescriptor());
	data.writeInt32(presentationId);
	data.writeInt32(programId);
	status_t status = remote()->transact(SELECT_PRESENTATION, data, &reply);
	if (status == NO_ERROR) {
	status = reply.readInt32();
	}
	return status;
	}

	virtual status_t getTimestamp(AudioTimestamp& timestamp) {
	Parcel data, reply;
	data.writeInterfaceToken(IAudioTrack::getInterfaceDescriptor());
	status_t status = remote()->transact(GET_TIMESTAMP, data, &reply);
	if (status == NO_ERROR) {
	status = reply.readInt32();
	if (status == NO_ERROR) {
	timestamp.mPosition = reply.readInt32();
	timestamp.mTime.tv_sec = reply.readInt32();
	timestamp.mTime.tv_nsec = reply.readInt32();
	}
	}
	return status;
	}

	virtual void signal() {
	Parcel data, reply;
	data.writeInterfaceToken(IAudioTrack::getInterfaceDescriptor());
	remote()->transact(SIGNAL, data, &reply);
	}

	virtual VolumeShaper::Status applyVolumeShaper(
	const sp<VolumeShaper::Configuration>& configuration,
	const sp<VolumeShaper::Operation>& operation) {
	Parcel data, reply;
	data.writeInterfaceToken(IAudioTrack::getInterfaceDescriptor());

	status_t status = configuration.get() == nullptr
	? data.writeInt32(0)
	: data.writeInt32(1)
	?: configuration->writeToParcel(&data);
	if (status != NO_ERROR) {
	return VolumeShaper::Status(status);
	}

	status = operation.get() == nullptr
	? status = data.writeInt32(0)
	: data.writeInt32(1)
	?: operation->writeToParcel(&data);
	if (status != NO_ERROR) {
	return VolumeShaper::Status(status);
	}

	int32_t remoteVolumeShaperStatus;
	status = remote()->transact(APPLY_VOLUME_SHAPER, data, &reply)
	?: reply.readInt32(&remoteVolumeShaperStatus);

	return VolumeShaper::Status(status ?: remoteVolumeShaperStatus);
	}

	virtual sp<VolumeShaper::State> getVolumeShaperState(int id) {
	Parcel data, reply;
	data.writeInterfaceToken(IAudioTrack::getInterfaceDescriptor());

	data.writeInt32(id);
	status_t status = remote()->transact(GET_VOLUME_SHAPER_STATE, data, &reply);
	if (status != NO_ERROR) {
	return nullptr;
	}
	sp<VolumeShaper::State> state = new VolumeShaper::State;
	status = state->readFromParcel(&reply);
	if (status != NO_ERROR) {
	return nullptr;
	}
	return state;
	}
	};

	IMPLEMENT_META_INTERFACE(AudioTrack, "android.media.IAudioTrack");

	// ----------------------------------------------------------------------

	status_t BnAudioTrack::onTransact(
	uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
	{
	switch (code) {
	case GET_CBLK: {
	CHECK_INTERFACE(IAudioTrack, data, reply);
	reply->writeStrongBinder(IInterface::asBinder(getCblk()));
	return NO_ERROR;
	} break;
	case START: {
	CHECK_INTERFACE(IAudioTrack, data, reply);
	reply->writeInt32(start());
	return NO_ERROR;
	} break;
	case STOP: {
	CHECK_INTERFACE(IAudioTrack, data, reply);
	stop();
	return NO_ERROR;
	} break;
	case FLUSH: {
	CHECK_INTERFACE(IAudioTrack, data, reply);
	flush();
	return NO_ERROR;
	} break;
	case PAUSE: {
	CHECK_INTERFACE(IAudioTrack, data, reply);
	pause();
	return NO_ERROR;
	}
	case ATTACH_AUX_EFFECT: {
	CHECK_INTERFACE(IAudioTrack, data, reply);
	reply->writeInt32(attachAuxEffect(data.readInt32()));
	return NO_ERROR;
	} break;
	case SET_PARAMETERS: {
	CHECK_INTERFACE(IAudioTrack, data, reply);
	String8 keyValuePairs(data.readString8());
	reply->writeInt32(setParameters(keyValuePairs));
	return NO_ERROR;
	} break;
	case SELECT_PRESENTATION: {
	CHECK_INTERFACE(IAudioTrack, data, reply);
	reply->writeInt32(selectPresentation(data.readInt32(), data.readInt32()));
	return NO_ERROR;
	} break;
	case GET_TIMESTAMP: {
	CHECK_INTERFACE(IAudioTrack, data, reply);
	AudioTimestamp timestamp;
	status_t status = getTimestamp(timestamp);
	reply->writeInt32(status);
	if (status == NO_ERROR) {
	reply->writeInt32(timestamp.mPosition);
	reply->writeInt32(timestamp.mTime.tv_sec);
	reply->writeInt32(timestamp.mTime.tv_nsec);
	}
	return NO_ERROR;
	} break;
	case SIGNAL: {
	CHECK_INTERFACE(IAudioTrack, data, reply);
	signal();
	return NO_ERROR;
	} break;
	case APPLY_VOLUME_SHAPER: {
	CHECK_INTERFACE(IAudioTrack, data, reply);
	sp<VolumeShaper::Configuration> configuration;
	sp<VolumeShaper::Operation> operation;

	int32_t present;
	status_t status = data.readInt32(&present);
	if (status == NO_ERROR && present != 0) {
	configuration = new VolumeShaper::Configuration();
	status = configuration->readFromParcel(&data);
	}
	status = status ?: data.readInt32(&present);
	if (status == NO_ERROR && present != 0) {
	operation = new VolumeShaper::Operation();
	status = operation->readFromParcel(&data);
	}
	if (status == NO_ERROR) {
	status = (status_t)applyVolumeShaper(configuration, operation);
	}
	reply->writeInt32(status);
	return NO_ERROR;
	} break;
	case GET_VOLUME_SHAPER_STATE: {
	CHECK_INTERFACE(IAudioTrack, data, reply);
	int id;
	status_t status = data.readInt32(&id);
	if (status == NO_ERROR) {
	sp<VolumeShaper::State> state = getVolumeShaperState(id);
	if (state.get() != nullptr) {
	status = state->writeToParcel(reply);
	}
	}
	return NO_ERROR;
	} break;
	default:
	return BBinder::onTransact(code, data, reply, flags);
	}
	}

	} // namespace android