class ugcs::vsm::Android_serial_processor

Overview

Working with serial ports on Android platform. More…

#include <android_serial_processor.h>

class Android_serial_processor: public ugcs::vsm::Request_context
{
public:
    // typedefs

    typedef std::shared_ptr<Android_serial_processor> Ptr;
    typedef std::weak_ptr<Android_serial_processor> Weak_ptr;
    typedef Callback_proxy<void, Io_stream::Ref> Open_handler;

    // classes

    class Open_request;
    class Read_request;
    class Stream;
    class Stream_entry;
    class Write_request;

    // methods

    template <typename... Args>
    static Ptr Create(Args&&... args);

    template <typename... Args>
    static Ptr Get_instance(Args&&... args);

    static std::list<std::string> Enumerate_port_names();

    Operation_waiter Open(
        const std::string& port_name,
        const Stream::Mode& mode = Stream::Mode(),
        Open_handler completion_handler = Make_dummy_callback<void, Stream::Ref>(),
        Request_completion_context::Ptr comp_ctx = Request_temp_completion_context::Create()
        );
};

Inherited Members

public:
    // typedefs

    typedef std::shared_ptr<Request_container> Ptr;
    typedef std::weak_ptr<Request_container> Weak_ptr;
    typedef std::shared_ptr<Request_context> Ptr;
    typedef std::weak_ptr<Request_context> Weak_ptr;

    // enums

    enum Type;

    // classes

    class Request;
    class Request_waiter;

    // methods

    template <typename... Args>
    static Ptr Create(Args&&... args);

    virtual Type Get_type() const;
    bool Check_type(Type mask);
    void Submit_request(Request::Ptr request);
    void Submit_request_locked(Request::Ptr request, Request_waiter::Locker locker);
    int Process_requests(int requests_limit = 0);
    int Process_requests(std::unique_lock<std::mutex>& lock, int requests_limit = 0);
    void Set_waiter(Request_waiter::Ptr waiter);
    Request_waiter::Ptr Get_waiter() const;
    const std::string& Get_name();
    void Enable();
    void Disable();
    bool Is_enabled() const;

    template <typename... Args>
    static Ptr Create(Args&&... args);

    virtual Type Get_type() const;
    Request_container(const std::string& name, Request_waiter::Ptr waiter = Request_waiter::Create());

Detailed Documentation

Working with serial ports on Android platform.

It includes also Java-side part it interacts with.

Typedefs

typedef std::shared_ptr<Android_serial_processor> Ptr

Pointer type.

typedef std::weak_ptr<Android_serial_processor> Weak_ptr

Pointer type.

typedef Callback_proxy<void, Io_stream::Ref> Open_handler

Default prototype for open operation completion handler.

Stream argument is nun-null if succeeded, null otherwise.

Methods

template <typename... Args>
static Ptr Create(Args&&... args)

Create an instance.

template <typename... Args>
static Ptr Get_instance(Args&&... args)

Get global or create new processor instance.

Operation_waiter Open(
    const std::string& port_name,
    const Stream::Mode& mode = Stream::Mode(),
    Open_handler completion_handler = Make_dummy_callback<void, Stream::Ref>(),
    Request_completion_context::Ptr comp_ctx = Request_temp_completion_context::Create()
    )

Open serial device stream.

Parameters:

port_name

Name returned by Enumerate_port_names() method.

mode

Port mode.

Returns:

Operation waiter for open request.