blob: 19b7d6e8d9c1ecf4dc02b30f41f51f238c635efa [file] [log] [blame]
/*
* Copyright (C) 2012 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.
*/
#include <sys/socket.h>
#include <common_time/ICommonClock.h>
#include <binder/Parcel.h>
#include "utils.h"
namespace android {
/***** ICommonClock *****/
enum {
IS_COMMON_TIME_VALID = IBinder::FIRST_CALL_TRANSACTION,
COMMON_TIME_TO_LOCAL_TIME,
LOCAL_TIME_TO_COMMON_TIME,
GET_COMMON_TIME,
GET_COMMON_FREQ,
GET_LOCAL_TIME,
GET_LOCAL_FREQ,
GET_ESTIMATED_ERROR,
GET_TIMELINE_ID,
GET_STATE,
GET_MASTER_ADDRESS,
REGISTER_LISTENER,
UNREGISTER_LISTENER,
};
const String16 ICommonClock::kServiceName("common_time.clock");
const uint64_t ICommonClock::kInvalidTimelineID = 0;
const int32_t ICommonClock::kErrorEstimateUnknown = 0x7FFFFFFF;
class BpCommonClock : public BpInterface<ICommonClock>
{
public:
BpCommonClock(const sp<IBinder>& impl)
: BpInterface<ICommonClock>(impl) {}
virtual status_t isCommonTimeValid(bool* valid, uint32_t* timelineID) {
Parcel data, reply;
data.writeInterfaceToken(ICommonClock::getInterfaceDescriptor());
status_t status = remote()->transact(IS_COMMON_TIME_VALID,
data,
&reply);
if (status == OK) {
status = reply.readInt32();
if (status == OK) {
*valid = reply.readInt32();
*timelineID = reply.readInt32();
}
}
return status;
}
virtual status_t commonTimeToLocalTime(int64_t commonTime,
int64_t* localTime) {
Parcel data, reply;
data.writeInterfaceToken(ICommonClock::getInterfaceDescriptor());
data.writeInt64(commonTime);
status_t status = remote()->transact(COMMON_TIME_TO_LOCAL_TIME,
data, &reply);
if (status == OK) {
status = reply.readInt32();
if (status == OK) {
*localTime = reply.readInt64();
}
}
return status;
}
virtual status_t localTimeToCommonTime(int64_t localTime,
int64_t* commonTime) {
Parcel data, reply;
data.writeInterfaceToken(ICommonClock::getInterfaceDescriptor());
data.writeInt64(localTime);
status_t status = remote()->transact(LOCAL_TIME_TO_COMMON_TIME,
data, &reply);
if (status == OK) {
status = reply.readInt32();
if (status == OK) {
*commonTime = reply.readInt64();
}
}
return status;
}
virtual status_t getCommonTime(int64_t* commonTime) {
Parcel data, reply;
data.writeInterfaceToken(ICommonClock::getInterfaceDescriptor());
status_t status = remote()->transact(GET_COMMON_TIME, data, &reply);
if (status == OK) {
status = reply.readInt32();
if (status == OK) {
*commonTime = reply.readInt64();
}
}
return status;
}
virtual status_t getCommonFreq(uint64_t* freq) {
Parcel data, reply;
data.writeInterfaceToken(ICommonClock::getInterfaceDescriptor());
status_t status = remote()->transact(GET_COMMON_FREQ, data, &reply);
if (status == OK) {
status = reply.readInt32();
if (status == OK) {
*freq = reply.readInt64();
}
}
return status;
}
virtual status_t getLocalTime(int64_t* localTime) {
Parcel data, reply;
data.writeInterfaceToken(ICommonClock::getInterfaceDescriptor());
status_t status = remote()->transact(GET_LOCAL_TIME, data, &reply);
if (status == OK) {
status = reply.readInt32();
if (status == OK) {
*localTime = reply.readInt64();
}
}
return status;
}
virtual status_t getLocalFreq(uint64_t* freq) {
Parcel data, reply;
data.writeInterfaceToken(ICommonClock::getInterfaceDescriptor());
status_t status = remote()->transact(GET_LOCAL_FREQ, data, &reply);
if (status == OK) {
status = reply.readInt32();
if (status == OK) {
*freq = reply.readInt64();
}
}
return status;
}
virtual status_t getEstimatedError(int32_t* estimate) {
Parcel data, reply;
data.writeInterfaceToken(ICommonClock::getInterfaceDescriptor());
status_t status = remote()->transact(GET_ESTIMATED_ERROR, data, &reply);
if (status == OK) {
status = reply.readInt32();
if (status == OK) {
*estimate = reply.readInt32();
}
}
return status;
}
virtual status_t getTimelineID(uint64_t* id) {
Parcel data, reply;
data.writeInterfaceToken(ICommonClock::getInterfaceDescriptor());
status_t status = remote()->transact(GET_TIMELINE_ID, data, &reply);
if (status == OK) {
status = reply.readInt32();
if (status == OK) {
*id = static_cast<uint64_t>(reply.readInt64());
}
}
return status;
}
virtual status_t getState(State* state) {
Parcel data, reply;
data.writeInterfaceToken(ICommonClock::getInterfaceDescriptor());
status_t status = remote()->transact(GET_STATE, data, &reply);
if (status == OK) {
status = reply.readInt32();
if (status == OK) {
*state = static_cast<State>(reply.readInt32());
}
}
return status;
}
virtual status_t getMasterAddr(struct sockaddr_storage* addr) {
Parcel data, reply;
data.writeInterfaceToken(ICommonClock::getInterfaceDescriptor());
status_t status = remote()->transact(GET_MASTER_ADDRESS, data, &reply);
if (status == OK) {
status = reply.readInt32();
if (status == OK)
deserializeSockaddr(&reply, addr);
}
return status;
}
virtual status_t registerListener(
const sp<ICommonClockListener>& listener) {
Parcel data, reply;
data.writeInterfaceToken(ICommonClock::getInterfaceDescriptor());
data.writeStrongBinder(IInterface::asBinder(listener));
status_t status = remote()->transact(REGISTER_LISTENER, data, &reply);
if (status == OK) {
status = reply.readInt32();
}
return status;
}
virtual status_t unregisterListener(
const sp<ICommonClockListener>& listener) {
Parcel data, reply;
data.writeInterfaceToken(ICommonClock::getInterfaceDescriptor());
data.writeStrongBinder(IInterface::asBinder(listener));
status_t status = remote()->transact(UNREGISTER_LISTENER, data, &reply);
if (status == OK) {
status = reply.readInt32();
}
return status;
}
};
IMPLEMENT_META_INTERFACE(CommonClock, "android.os.ICommonClock");
status_t BnCommonClock::onTransact(uint32_t code,
const Parcel& data,
Parcel* reply,
uint32_t flags) {
switch(code) {
case IS_COMMON_TIME_VALID: {
CHECK_INTERFACE(ICommonClock, data, reply);
bool valid;
uint32_t timelineID;
status_t status = isCommonTimeValid(&valid, &timelineID);
reply->writeInt32(status);
if (status == OK) {
reply->writeInt32(valid);
reply->writeInt32(timelineID);
}
return OK;
} break;
case COMMON_TIME_TO_LOCAL_TIME: {
CHECK_INTERFACE(ICommonClock, data, reply);
int64_t commonTime = data.readInt64();
int64_t localTime;
status_t status = commonTimeToLocalTime(commonTime, &localTime);
reply->writeInt32(status);
if (status == OK) {
reply->writeInt64(localTime);
}
return OK;
} break;
case LOCAL_TIME_TO_COMMON_TIME: {
CHECK_INTERFACE(ICommonClock, data, reply);
int64_t localTime = data.readInt64();
int64_t commonTime;
status_t status = localTimeToCommonTime(localTime, &commonTime);
reply->writeInt32(status);
if (status == OK) {
reply->writeInt64(commonTime);
}
return OK;
} break;
case GET_COMMON_TIME: {
CHECK_INTERFACE(ICommonClock, data, reply);
int64_t commonTime;
status_t status = getCommonTime(&commonTime);
reply->writeInt32(status);
if (status == OK) {
reply->writeInt64(commonTime);
}
return OK;
} break;
case GET_COMMON_FREQ: {
CHECK_INTERFACE(ICommonClock, data, reply);
uint64_t freq;
status_t status = getCommonFreq(&freq);
reply->writeInt32(status);
if (status == OK) {
reply->writeInt64(freq);
}
return OK;
} break;
case GET_LOCAL_TIME: {
CHECK_INTERFACE(ICommonClock, data, reply);
int64_t localTime;
status_t status = getLocalTime(&localTime);
reply->writeInt32(status);
if (status == OK) {
reply->writeInt64(localTime);
}
return OK;
} break;
case GET_LOCAL_FREQ: {
CHECK_INTERFACE(ICommonClock, data, reply);
uint64_t freq;
status_t status = getLocalFreq(&freq);
reply->writeInt32(status);
if (status == OK) {
reply->writeInt64(freq);
}
return OK;
} break;
case GET_ESTIMATED_ERROR: {
CHECK_INTERFACE(ICommonClock, data, reply);
int32_t error;
status_t status = getEstimatedError(&error);
reply->writeInt32(status);
if (status == OK) {
reply->writeInt32(error);
}
return OK;
} break;
case GET_TIMELINE_ID: {
CHECK_INTERFACE(ICommonClock, data, reply);
uint64_t id;
status_t status = getTimelineID(&id);
reply->writeInt32(status);
if (status == OK) {
reply->writeInt64(static_cast<int64_t>(id));
}
return OK;
} break;
case GET_STATE: {
CHECK_INTERFACE(ICommonClock, data, reply);
State state;
status_t status = getState(&state);
reply->writeInt32(status);
if (status == OK) {
reply->writeInt32(static_cast<int32_t>(state));
}
return OK;
} break;
case GET_MASTER_ADDRESS: {
CHECK_INTERFACE(ICommonClock, data, reply);
struct sockaddr_storage addr;
status_t status = getMasterAddr(&addr);
if ((status == OK) && !canSerializeSockaddr(&addr)) {
status = UNKNOWN_ERROR;
}
reply->writeInt32(status);
if (status == OK) {
serializeSockaddr(reply, &addr);
}
return OK;
} break;
case REGISTER_LISTENER: {
CHECK_INTERFACE(ICommonClock, data, reply);
sp<ICommonClockListener> listener =
interface_cast<ICommonClockListener>(data.readStrongBinder());
status_t status = registerListener(listener);
reply->writeInt32(status);
return OK;
} break;
case UNREGISTER_LISTENER: {
CHECK_INTERFACE(ICommonClock, data, reply);
sp<ICommonClockListener> listener =
interface_cast<ICommonClockListener>(data.readStrongBinder());
status_t status = unregisterListener(listener);
reply->writeInt32(status);
return OK;
} break;
}
return BBinder::onTransact(code, data, reply, flags);
}
/***** ICommonClockListener *****/
enum {
ON_TIMELINE_CHANGED = IBinder::FIRST_CALL_TRANSACTION,
};
class BpCommonClockListener : public BpInterface<ICommonClockListener>
{
public:
BpCommonClockListener(const sp<IBinder>& impl)
: BpInterface<ICommonClockListener>(impl) {}
virtual void onTimelineChanged(uint64_t timelineID) {
Parcel data, reply;
data.writeInterfaceToken(
ICommonClockListener::getInterfaceDescriptor());
data.writeInt64(timelineID);
remote()->transact(ON_TIMELINE_CHANGED, data, &reply);
}
};
IMPLEMENT_META_INTERFACE(CommonClockListener,
"android.os.ICommonClockListener");
status_t BnCommonClockListener::onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) {
switch(code) {
case ON_TIMELINE_CHANGED: {
CHECK_INTERFACE(ICommonClockListener, data, reply);
uint32_t timelineID = data.readInt64();
onTimelineChanged(timelineID);
return NO_ERROR;
} break;
}
return BBinder::onTransact(code, data, reply, flags);
}
}; // namespace android