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

include/gui/DisplayEventReceiver.h

+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;

};



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

include/gui/IDisplayEventConnection.h

+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.

libs/gui/BitTube.cpp

+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

libs/gui/DisplayEventReceiver.cpp

+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);

}



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

libs/gui/IDisplayEventConnection.cpp

+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;