personalhealthdevice.h

Go to the documentation of this file.

/*
 *   Copyright 2014-2015 The 4S Foundation (www.4s-online.dk)
 *
 *   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.
 */

// TODO: Revisit all the documentation
#ifndef PERSONALHEALTHDEVICE_H
#define PERSONALHEALTHDEVICE_H

#include "FSYS/basemsg.h"
#include "FSYS/handle.h"

#include <cstdint>
#include <memory>
#include <string>
#include <vector>

// FIXME: redefine/refactor errortype to the actual error type when chosen...
typedef uint32_t errortype;

namespace PAL {




/* ************************************************************ */
/*   Messages communicated between the PAL and session layers   */
/* ************************************************************ */


class PHDRegisterDatatypeMsg : public FSYS::BaseMsg {
public:
    uint16_t datatype;
};

class PHDUnregisterDatatypeMsg : public FSYS::BaseMsg {
public:
    uint16_t datatype;
};

class PHDConnectIndicationMsg : public FSYS::BaseMsg {
public:
    FSYS::Handle virtualDevice;
    FSYS::Handle physicalDevice;
    uint16_t datatype;
    std::string virtualDisplayname;
    std::string physicalDisplayname;
};

class PHDDisconnectIndicationMsg : public FSYS::BaseMsg {
public:
    FSYS::Handle virtualDevice;
    errortype error;
};

class PHDDataTransferMsg : public FSYS::BaseMsg {
public:
    FSYS::Handle virtualDevice;
    std::vector<uint8_t> apdu;
    bool reliable;
};

class PHDDisconnectMsg : public FSYS::BaseMsg {
public:
    FSYS::Handle virtualDevice;
};

class PHDConnectIndicationBluetoothMsg : public PHDConnectIndicationMsg {
public:
    std::string bluetoothAddress;
    std::string bluetoothName;
};

class PHDConnectIndicationUSBMsg : public PHDConnectIndicationMsg {
public:

};

class PHDConnectIndicationZigBeeMsg : public PHDConnectIndicationMsg {
public:

};




/* ************************************************************ */
/*                       General Interface                      */
/* ************************************************************ */


class PhysicalPHD : public FSYS::Handle {
public:

    PhysicalPHD() {}

    PhysicalPHD(FSYS::Handle &h) : FSYS::Handle(h) {}

    virtual ~PhysicalPHD() {}

    virtual std::string getDisplayName() const noexcept =0;
};




class VirtualPHD : public FSYS::Handle {
public:

    VirtualPHD() {}

    VirtualPHD(FSYS::Handle &h) : FSYS::Handle(h) {}

    virtual ~VirtualPHD() {}

    // The returned reference will be valid as long as this VirtualPHD object is alive
    virtual PhysicalPHD &getPhysicalDevice() noexcept =0;
    virtual const PhysicalPHD &getPhysicalDevice() const noexcept =0;

    virtual uint16_t getDatatype() const noexcept =0;

    virtual std::string getDisplayName() const noexcept =0;
};




class PersonalHealthDeviceConnector {
protected:

    virtual void registerDatatype(uint16_t datatype) =0;

    virtual void unregisterDatatype(uint16_t datatype) noexcept =0;

    virtual void connectIndication(std::shared_ptr<VirtualPHD> device)
                                                                    noexcept =0;

    virtual void disconnectIndication(std::shared_ptr<VirtualPHD> device,
                                      errortype error=0) noexcept =0;

    virtual void apduReceived(std::shared_ptr<VirtualPHD> device,
                              std::shared_ptr<std::vector<uint8_t> > apdu,
                              bool reliableTransport) noexcept =0;

    virtual void sendApduPrimary(std::shared_ptr<VirtualPHD> device,
                                 std::shared_ptr<std::vector<uint8_t> > apdu)
                                                                    noexcept =0;

    virtual void disconnect(std::shared_ptr<VirtualPHD> device) noexcept =0;

};




/* ************************************************************ */
/*                      Bluetooth "classic"                     */
/* ************************************************************ */


class PHDBluetoothDevice : public PhysicalPHD {
public:

    PHDBluetoothDevice() {}

    PHDBluetoothDevice(FSYS::Handle &h) : PhysicalPHD(h) {}

    virtual std::string getBTAddress() const noexcept =0;

    virtual std::string getBTName() const noexcept =0;
};




class PHDBluetoothConnector : virtual protected PersonalHealthDeviceConnector {

protected:

    virtual void sendApduStreaming(std::shared_ptr<VirtualPHD> device,
                                   std::shared_ptr<std::vector<uint8_t> > apdu)
                                                                    noexcept =0;
};




/* ************************************************************ */
/*                              USB                             */
/* ************************************************************ */

class PHDUSBDevice : public PhysicalPHD {
public:
    PHDUSBDevice() {}
    PHDUSBDevice(FSYS::Handle &h) : PhysicalPHD(h) {}


};


class PHDUSBConnector : virtual protected PersonalHealthDeviceConnector {
protected:


};




/* ************************************************************ */
/*                             ZigBee                           */
/* ************************************************************ */

class PHDZigBeeDevice : public PhysicalPHD {
public:
    PHDZigBeeDevice() {}
    PHDZigBeeDevice(FSYS::Handle &h) : PhysicalPHD(h) {}


};


class PHDZigBeeConnector : virtual protected PersonalHealthDeviceConnector {
protected:


};




/* ************************************************************ */
/*             Abstract Provider and Handler classes            */
/* ************************************************************ */

class PersonalHealthDeviceHandler :
        protected PHDBluetoothConnector,
        protected PHDUSBConnector,
        protected PHDZigBeeConnector {

public:
    virtual ~PersonalHealthDeviceHandler();

protected:
    PersonalHealthDeviceHandler();
    void registerDatatype(uint16_t datatype);
    void unregisterDatatype(uint16_t datatype) noexcept;
    void sendApduPrimary(std::shared_ptr<VirtualPHD> device,
                       std::shared_ptr<std::vector<uint8_t> > apdu) noexcept;
    void disconnect(std::shared_ptr<VirtualPHD> device) noexcept;

    void sendApduStreaming(std::shared_ptr<VirtualPHD> device,
                       std::shared_ptr<std::vector<uint8_t> > apdu) noexcept;

private:
    // Opaque class will wrap the private parts
    class PrivatePHDHandler;
    PrivatePHDHandler *privateParts;
};




class PersonalHealthDeviceProviderBase :
                               virtual protected PersonalHealthDeviceConnector {

public:
    virtual ~PersonalHealthDeviceProviderBase();

protected:
    PersonalHealthDeviceProviderBase();
    void connectIndication(std::shared_ptr<VirtualPHD> device) noexcept;

    void disconnectIndication(std::shared_ptr<VirtualPHD> device,
                              errortype error) noexcept;

    void apduReceived(std::shared_ptr<VirtualPHD> device,
                      std::shared_ptr<std::vector<uint8_t> > apdu,
                      bool reliableTransport) noexcept;

    // Opaque class will wrap the private parts
    class PrivatePHDProvider;
    PrivatePHDProvider *privateParts;
};




class PHDBluetoothProvider :
        protected PHDBluetoothConnector,
        protected PersonalHealthDeviceProviderBase {
    friend PrivatePHDProvider;
};





/*
class PlatformProviderLauncherBase {
public:
    PlatformProviderLauncherBase();
    virtual ~PlatformProviderLauncherBase();
    // Skal der være private copy/assignment ctor og operator?
protected:
    virtual Terminator makeBluetoothProvider();
    virtual Terminator makeUSBProvider();
    virtual Terminator makeZigBeeProvider();

};


class PlatformProviderLauncher : public PlatformProviderLauncherBase {
private:
    Terminator makeBluetoothProvider();
    Terminator makeUSBProvider();
    Terminator makeZigBeeProvider();
};

*/

} // End of namespace


#endif // PERSONALHEALTHDEVICE_H