Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 27c81155 authored by Dan Stoza's avatar Dan Stoza
Browse files

libgui: Format BitTube and move into gui namespace

Reformats BitTube using the framework default .clang-format and moves
it into the android::gui namespace.

Test: m -j + manual testing
Change-Id: I5ea748b809f37c2ec4dcfb41e7b84daf7a084368
parent 1e438d2c
Loading
Loading
Loading
Loading
+7 −4
Original line number Diff line number Diff line
@@ -32,9 +32,12 @@ namespace android {

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

class BitTube;
class IDisplayEventConnection;

namespace gui {
class BitTube;
} // namespace gui

static inline constexpr uint32_t fourcc(char c1, char c2, char c3, char c4) {
    return static_cast<uint32_t>(c1) << 24 |
        static_cast<uint32_t>(c2) << 16 |
@@ -108,14 +111,14 @@ public:
     * should be destroyed and getEvents() shouldn't be called again.
     */
    ssize_t getEvents(Event* events, size_t count);
    static ssize_t getEvents(const sp<BitTube>& dataChannel,
    static ssize_t getEvents(const sp<gui::BitTube>& dataChannel,
            Event* events, size_t count);

    /*
     * sendEvents write events to the queue and returns how many events were
     * written.
     */
    static ssize_t sendEvents(const sp<BitTube>& dataChannel,
    static ssize_t sendEvents(const sp<gui::BitTube>& dataChannel,
            Event const* events, size_t count);

    /*
@@ -134,7 +137,7 @@ public:

private:
    sp<IDisplayEventConnection> mEventConnection;
    sp<BitTube> mDataChannel;
    sp<gui::BitTube> mDataChannel;
};

// ----------------------------------------------------------------------------
+3 −1
Original line number Diff line number Diff line
@@ -25,7 +25,9 @@

namespace android {

namespace gui {
class BitTube;
} // namespace gui

class IDisplayEventConnection : public IInterface {
public:
@@ -34,7 +36,7 @@ public:
    /*
     * getDataChannel() returns a BitTube where to receive the events from
     */
    virtual status_t getDataChannel(sp<BitTube>* outChannel) const = 0;
    virtual status_t getDataChannel(sp<gui::BitTube>* outChannel) const = 0;

    /*
     * setVsyncRate() sets the vsync event delivery rate. A value of 1 returns every vsync event.
+36 −57
Original line number Diff line number Diff line
@@ -17,8 +17,8 @@
#include <private/gui/BitTube.h>

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

#include <fcntl.h>
#include <unistd.h>
@@ -27,45 +27,33 @@

#include <binder/Parcel.h>


namespace android {
// ----------------------------------------------------------------------------
namespace gui {

// Socket buffer size.  The default is typically about 128KB, which is much larger than
// we really need.  So we make it smaller.
// Socket buffer size.  The default is typically about 128KB, which is much larger than we really
// need. So we make it smaller.
static const size_t DEFAULT_SOCKET_BUFFER_SIZE = 4 * 1024;


BitTube::BitTube()
    : mSendFd(-1), mReceiveFd(-1)
{
BitTube::BitTube() : mSendFd(-1), mReceiveFd(-1) {
    init(DEFAULT_SOCKET_BUFFER_SIZE, DEFAULT_SOCKET_BUFFER_SIZE);
}

BitTube::BitTube(size_t bufsize)
    : mSendFd(-1), mReceiveFd(-1)
{
BitTube::BitTube(size_t bufsize) : mSendFd(-1), mReceiveFd(-1) {
    init(bufsize, bufsize);
}

BitTube::BitTube(const Parcel& data)
    : mSendFd(-1), mReceiveFd(-1)
{
BitTube::BitTube(const Parcel& data) : mSendFd(-1), mReceiveFd(-1) {
    mReceiveFd = dup(data.readFileDescriptor());
    if (mReceiveFd < 0) {
        mReceiveFd = -errno;
        ALOGE("BitTube(Parcel): can't dup filedescriptor (%s)",
                strerror(-mReceiveFd));
        ALOGE("BitTube(Parcel): can't dup filedescriptor (%s)", strerror(-mReceiveFd));
    }
}

BitTube::~BitTube()
{
    if (mSendFd >= 0)
        close(mSendFd);
BitTube::~BitTube() {
    if (mSendFd >= 0) close(mSendFd);

    if (mReceiveFd >= 0)
        close(mReceiveFd);
    if (mReceiveFd >= 0) close(mReceiveFd);
}

void BitTube::init(size_t rcvbuf, size_t sndbuf) {
@@ -74,7 +62,7 @@ void BitTube::init(size_t rcvbuf, size_t sndbuf) {
        size_t size = DEFAULT_SOCKET_BUFFER_SIZE;
        setsockopt(sockets[0], SOL_SOCKET, SO_RCVBUF, &rcvbuf, sizeof(rcvbuf));
        setsockopt(sockets[1], SOL_SOCKET, SO_SNDBUF, &sndbuf, sizeof(sndbuf));
        // sine we don't use the "return channel", we keep it small...
        // since we don't use the "return channel", we keep it small...
        setsockopt(sockets[0], SOL_SOCKET, SO_SNDBUF, &size, sizeof(size));
        setsockopt(sockets[1], SOL_SOCKET, SO_RCVBUF, &size, sizeof(size));
        fcntl(sockets[0], F_SETFL, O_NONBLOCK);
@@ -87,26 +75,22 @@ void BitTube::init(size_t rcvbuf, size_t sndbuf) {
    }
}

status_t BitTube::initCheck() const
{
status_t BitTube::initCheck() const {
    if (mReceiveFd < 0) {
        return status_t(mReceiveFd);
    }
    return NO_ERROR;
}

int BitTube::getFd() const
{
int BitTube::getFd() const {
    return mReceiveFd;
}

int BitTube::getSendFd() const
{
int BitTube::getSendFd() const {
    return mSendFd;
}

ssize_t BitTube::write(void const* vaddr, size_t size)
{
ssize_t BitTube::write(void const* vaddr, size_t size) {
    ssize_t err, len;
    do {
        len = ::send(mSendFd, vaddr, size, MSG_DONTWAIT | MSG_NOSIGNAL);
@@ -116,25 +100,22 @@ ssize_t BitTube::write(void const* vaddr, size_t size)
    return err == 0 ? len : -err;
}

ssize_t BitTube::read(void* vaddr, size_t size)
{
ssize_t BitTube::read(void* vaddr, size_t size) {
    ssize_t err, len;
    do {
        len = ::recv(mReceiveFd, vaddr, size, MSG_DONTWAIT);
        err = len < 0 ? errno : 0;
    } while (err == EINTR);
    if (err == EAGAIN || err == EWOULDBLOCK) {
        // EAGAIN means that we have non-blocking I/O but there was
        // no data to be read. Nothing the client should care about.
        // EAGAIN means that we have non-blocking I/O but there was no data to be read. Nothing the
        // client should care about.
        return 0;
    }
    return err == 0 ? len : -err;
}

status_t BitTube::writeToParcel(Parcel* reply) const
{
    if (mReceiveFd < 0)
        return -EINVAL;
status_t BitTube::writeToParcel(Parcel* reply) const {
    if (mReceiveFd < 0) return -EINVAL;

    status_t result = reply->writeDupFileDescriptor(mReceiveFd);
    close(mReceiveFd);
@@ -142,36 +123,34 @@ status_t BitTube::writeToParcel(Parcel* reply) const
    return result;
}


ssize_t BitTube::sendObjects(const sp<BitTube>& tube,
        void const* events, size_t count, size_t objSize)
{
ssize_t BitTube::sendObjects(const sp<BitTube>& tube, void const* events, size_t count,
                             size_t objSize) {
    const char* vaddr = reinterpret_cast<const char*>(events);
    ssize_t size = tube->write(vaddr, count * objSize);

    // should never happen because of SOCK_SEQPACKET
    LOG_ALWAYS_FATAL_IF((size >= 0) && (size % static_cast<ssize_t>(objSize)),
            "BitTube::sendObjects(count=%zu, size=%zu), res=%zd (partial events were sent!)",
                        "BitTube::sendObjects(count=%zu, size=%zu), res=%zd (partial events were "
                        "sent!)",
                        count, objSize, size);

    // ALOGE_IF(size<0, "error %d sending %d events", size, count);
    return size < 0 ? size : size / static_cast<ssize_t>(objSize);
}

ssize_t BitTube::recvObjects(const sp<BitTube>& tube,
        void* events, size_t count, size_t objSize)
{
ssize_t BitTube::recvObjects(const sp<BitTube>& tube, void* events, size_t count, size_t objSize) {
    char* vaddr = reinterpret_cast<char*>(events);
    ssize_t size = tube->read(vaddr, count * objSize);

    // should never happen because of SOCK_SEQPACKET
    LOG_ALWAYS_FATAL_IF((size >= 0) && (size % static_cast<ssize_t>(objSize)),
            "BitTube::recvObjects(count=%zu, size=%zu), res=%zd (partial events were received!)",
                        "BitTube::recvObjects(count=%zu, size=%zu), res=%zd (partial events were "
                        "received!)",
                        count, objSize, size);

    // ALOGE_IF(size<0, "error %d receiving %d events", size, count);
    return size < 0 ? size : size / static_cast<ssize_t>(objSize);
}

// ----------------------------------------------------------------------------
}; // namespace android
} // namespace gui
} // namespace android
+4 −4
Original line number Diff line number Diff line
@@ -83,16 +83,16 @@ ssize_t DisplayEventReceiver::getEvents(DisplayEventReceiver::Event* events,
    return DisplayEventReceiver::getEvents(mDataChannel, events, count);
}

ssize_t DisplayEventReceiver::getEvents(const sp<BitTube>& dataChannel,
ssize_t DisplayEventReceiver::getEvents(const sp<gui::BitTube>& dataChannel,
        Event* events, size_t count)
{
    return BitTube::recvObjects(dataChannel, events, count);
    return gui::BitTube::recvObjects(dataChannel, events, count);
}

ssize_t DisplayEventReceiver::sendEvents(const sp<BitTube>& dataChannel,
ssize_t DisplayEventReceiver::sendEvents(const sp<gui::BitTube>& dataChannel,
        Event const* events, size_t count)
{
    return BitTube::sendObjects(dataChannel, events, count);
    return gui::BitTube::sendObjects(dataChannel, events, count);
}

// ---------------------------------------------------------------------------
+3 −3
Original line number Diff line number Diff line
@@ -31,11 +31,11 @@ public:

    ~BpDisplayEventConnection() override;

    status_t getDataChannel(sp<BitTube>* outChannel) const override {
    status_t getDataChannel(sp<gui::BitTube>* outChannel) const override {
        Parcel data, reply;
        data.writeInterfaceToken(IDisplayEventConnection::getInterfaceDescriptor());
        remote()->transact(GET_DATA_CHANNEL, data, &reply);
        *outChannel = new BitTube(reply);
        *outChannel = new gui::BitTube(reply);
        return NO_ERROR;
    }

@@ -65,7 +65,7 @@ status_t BnDisplayEventConnection::onTransact(uint32_t code, const Parcel& data,
    switch (code) {
        case GET_DATA_CHANNEL: {
            CHECK_INTERFACE(IDisplayEventConnection, data, reply);
            sp<BitTube> channel;
            sp<gui::BitTube> channel;
            getDataChannel(&channel);
            channel->writeToParcel(reply);
            return NO_ERROR;
Loading