loc_api/libloc_api_50001/loc_eng_agps.h

/* Copyright (c) 2011-2013, The Linux Foundation. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above
 *       copyright notice, this list of conditions and the following
 *       disclaimer in the documentation and/or other materials provided
 *       with the distribution.
 *     * Neither the name of The Linux Foundation, nor the names of its
 *       contributors may be used to endorse or promote products derived
 *       from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 */

#ifndef __LOC_ENG_AGPS_H__
#define __LOC_ENG_AGPS_H__

#include <stdbool.h>
#include <ctype.h>
#include <string.h>
#include <arpa/inet.h>
#include <hardware/gps.h>
#include <gps_extended.h>
#include <loc_core_log.h>
#include <linked_list.h>
#include <loc_timer.h>
#include <LocEngAdapter.h>

// forward declaration
class AgpsStateMachine;
class Subscriber;

// NIF resource events
typedef enum {
    RSRC_SUBSCRIBE,
    RSRC_UNSUBSCRIBE,
    RSRC_GRANTED,
    RSRC_RELEASED,
    RSRC_DENIED,
    RSRC_STATUS_MAX
} AgpsRsrcStatus;

typedef enum {
    servicerTypeNoCbParam,
    servicerTypeAgps,
    servicerTypeExt
}servicerType;

//DS Callback struct
typedef struct {
    LocEngAdapter *mAdapter;
    AGpsStatusValue action;
}dsCbData;

// information bundle for subscribers
struct Notification {
    // goes to every subscriber
    static const int BROADCAST_ALL;
    // goes to every ACTIVE subscriber
    static const int BROADCAST_ACTIVE;
    // goes to every INACTIVE subscriber
    static const int BROADCAST_INACTIVE;

    // go to a specific subscriber
    const Subscriber* rcver;
    // broadcast
    const int groupID;
    // the new resource status event
    const AgpsRsrcStatus rsrcStatus;
    // should the subscriber be deleted after the notification
    const bool postNotifyDelete;

    // convenient constructor
    inline Notification(const int broadcast,
                        const AgpsRsrcStatus status,
                        const bool deleteAfterwards) :
        rcver(NULL), groupID(broadcast), rsrcStatus(status),
        postNotifyDelete(deleteAfterwards) {}

    // convenient constructor
    inline Notification(const Subscriber* subscriber,
                        const AgpsRsrcStatus status,
                        const bool deleteAfterwards) :
        rcver(subscriber), groupID(-1), rsrcStatus(status),
        postNotifyDelete(deleteAfterwards) {}

    // convenient constructor
    inline Notification(const int broadcast) :
        rcver(NULL), groupID(broadcast), rsrcStatus(RSRC_STATUS_MAX),
        postNotifyDelete(false) {}

    // convenient constructor
    inline Notification(const Subscriber* subscriber) :
        rcver(subscriber), groupID(-1), rsrcStatus(RSRC_STATUS_MAX),
        postNotifyDelete(false) {}
};

class AgpsState {
    // allows AgpsStateMachine to access private data
    // no class members are public.  We don't want
    // anyone but state machine to use state.
    friend class AgpsStateMachine;
    friend class DSStateMachine;
    // state transitions are done here.
    // Each state implements its own transitions (of course).
    inline virtual AgpsState* onRsrcEvent(AgpsRsrcStatus event, void* data) = 0;

protected:
    // handle back to state machine
    const AgpsStateMachine* mStateMachine;
    // each state has pointers to all 3 states
    // one of which is to itself.
    AgpsState* mReleasedState;
    AgpsState* mAcquiredState;
    AgpsState* mPendingState;
    AgpsState* mReleasingState;

    inline AgpsState(const AgpsStateMachine *stateMachine) :
        mStateMachine(stateMachine),
        mReleasedState(NULL),
        mAcquiredState(NULL),
        mPendingState(NULL),
        mReleasingState(NULL) {}
    virtual ~AgpsState() {}

public:
    // for logging purpose
    inline virtual char* whoami() = 0;
};

class Servicer {
    void (*callback)(void);
public:
    static Servicer* getServicer(servicerType type, void *cb_func);
    virtual int requestRsrc(void *cb_data);
    Servicer() {}
    Servicer(void *cb_func)
    { callback = (void(*)(void))(cb_func); }
    virtual ~Servicer(){}
    inline virtual char *whoami() {return (char*)"Servicer";}
};

class ExtServicer : public Servicer {
    int (*callbackExt)(void *cb_data);
public:
    int requestRsrc(void *cb_data);
    ExtServicer() {}
    ExtServicer(void *cb_func)
    { callbackExt = (int(*)(void *))(cb_func); }
    virtual ~ExtServicer(){}
    inline virtual char *whoami() {return (char*)"ExtServicer";}
};

class AGpsServicer : public Servicer {
    void (*callbackAGps)(AGpsStatus* status);
public:
    int requestRsrc(void *cb_data);
    AGpsServicer() {}
    AGpsServicer(void *cb_func)
    { callbackAGps = (void(*)(AGpsStatus *))(cb_func); }
    virtual ~AGpsServicer(){}
    inline virtual char *whoami() {return (char*)"AGpsServicer";}
};

class AgpsStateMachine {
protected:
    // a linked list of subscribers.
    void* mSubscribers;
    //handle to whoever provides the service
    Servicer *mServicer;
    // allows AgpsState to access private data
    // each state is really internal data to the
    // state machine, so it should be able to
    // access anything within the state machine.
    friend class AgpsState;
    // pointer to the current state.
    AgpsState* mStatePtr;
private:
    // NIF type: AGNSS or INTERNET.
    const AGpsExtType mType;
    // apn to the NIF.  Each state machine tracks
    // resource state of a particular NIF.  For each
    // NIF, there is also an active APN.
    char* mAPN;
    // for convenience, we don't do strlen each time.
    unsigned int mAPNLen;
    // bear
    AGpsBearerType mBearer;
    // ipv4 address for routing
    bool mEnforceSingleSubscriber;

public:
    AgpsStateMachine(servicerType servType, void *cb_func,
                     AGpsExtType type, bool enforceSingleSubscriber);
    virtual ~AgpsStateMachine();

    // self explanatory methods below
    void setAPN(const char* apn, unsigned int len);
    inline const char* getAPN() const { return (const char*)mAPN; }
    inline void setBearer(AGpsBearerType bearer) { mBearer = bearer; }
    inline AGpsBearerType getBearer() const { return mBearer; }
    inline AGpsExtType getType() const { return (AGpsExtType)mType; }

    // someone, a ATL client or BIT, is asking for NIF
    void subscribeRsrc(Subscriber *subscriber);

    // someone, a ATL client or BIT, is done with NIF
    bool unsubscribeRsrc(Subscriber *subscriber);

    // add a subscriber in the linked list, if not already there.
    void addSubscriber(Subscriber* subscriber) const;

    virtual void onRsrcEvent(AgpsRsrcStatus event);

    // put the data together and send the FW
    virtual int sendRsrcRequest(AGpsStatusValue action) const;

    //if list is empty, linked_list_empty returns 1
    //else if list is not empty, returns 0
    //so hasSubscribers() returns 1 if list is not empty
    //and returns 0 if list is empty
    inline bool hasSubscribers() const
    { return !linked_list_empty(mSubscribers); }

    bool hasActiveSubscribers() const;

    inline void dropAllSubscribers() const
    { linked_list_flush(mSubscribers); }

    // private. Only a state gets to call this.
    void notifySubscribers(Notification& notification) const;

};

class DSStateMachine : public AgpsStateMachine {
    static const unsigned char MAX_START_DATA_CALL_RETRIES;
    static const unsigned int DATA_CALL_RETRY_DELAY_MSEC;
    LocEngAdapter* mLocAdapter;
    unsigned char mRetries;
public:
    DSStateMachine(servicerType type,
                   void *cb_func,
                   LocEngAdapter* adapterHandle);
    int sendRsrcRequest(AGpsStatusValue action) const;
    void onRsrcEvent(AgpsRsrcStatus event);
    void retryCallback();
    void informStatus(AgpsRsrcStatus status, int ID) const;
    inline void incRetries() {mRetries++;}
    inline virtual char *whoami() {return (char*)"DSStateMachine";}
};

// each subscriber is a AGPS client.  In the case of ATL, there could be
// multiple clients from modem.  In the case of BIT, there is only one
// cilent from BIT daemon.
struct Subscriber {
    const uint32_t ID;
    const AgpsStateMachine* mStateMachine;
    inline Subscriber(const int id,
                      const AgpsStateMachine* stateMachine) :
        ID(id), mStateMachine(stateMachine) {}
    inline virtual ~Subscriber() {}

    virtual void setIPAddresses(uint32_t &v4, char* v6) = 0;
    inline virtual void setWifiInfo(char* ssid, char* password)
    { ssid[0] = 0; password[0] = 0; }

    inline virtual bool equals(const Subscriber *s) const
    { return ID == s->ID; }

    // notifies a subscriber a new NIF resource status, usually
    // either GRANTE, DENIED, or RELEASED
    virtual bool notifyRsrcStatus(Notification &notification) = 0;

    virtual bool waitForCloseComplete() { return false; }
    virtual void setInactive() {}
    virtual bool isInactive() { return false; }

    virtual Subscriber* clone() = 0;
    // checks if this notification is for me, i.e.
    // either has my id, or has a broadcast id.
    bool forMe(Notification &notification);
};

// BITSubscriber, created with requests from BIT daemon
struct BITSubscriber : public Subscriber {
    char mIPv6Addr[16];

    inline BITSubscriber(const AgpsStateMachine* stateMachine,
                         unsigned int ipv4, char* ipv6) :
        Subscriber(ipv4, stateMachine)
    {
        if (NULL == ipv6) {
            mIPv6Addr[0] = 0;
        } else {
            memcpy(mIPv6Addr, ipv6, sizeof(mIPv6Addr));
        }
    }

    virtual bool notifyRsrcStatus(Notification &notification);

    inline virtual void setIPAddresses(uint32_t &v4, char* v6)
    { v4 = ID; memcpy(v6, mIPv6Addr, sizeof(mIPv6Addr)); }

    virtual Subscriber* clone()
    {
        return new BITSubscriber(mStateMachine, ID, mIPv6Addr);
    }

    virtual bool equals(const Subscriber *s) const;
    inline virtual ~BITSubscriber(){}
};

// ATLSubscriber, created with requests from ATL
struct ATLSubscriber : public Subscriber {
    const LocEngAdapter* mLocAdapter;
    const bool mBackwardCompatibleMode;
    inline ATLSubscriber(const int id,
                         const AgpsStateMachine* stateMachine,
                         const LocEngAdapter* adapter,
                         const bool compatibleMode) :
        Subscriber(id, stateMachine), mLocAdapter(adapter),
        mBackwardCompatibleMode(compatibleMode){}
    virtual bool notifyRsrcStatus(Notification &notification);

    inline virtual void setIPAddresses(uint32_t &v4, char* v6)
    { v4 = INADDR_NONE; v6[0] = 0; }

    inline virtual Subscriber* clone()
    {
        return new ATLSubscriber(ID, mStateMachine, mLocAdapter,
                                 mBackwardCompatibleMode);
    }
    inline virtual ~ATLSubscriber(){}
};

// WIFISubscriber, created with requests from MSAPM or QuIPC
struct WIFISubscriber : public Subscriber {
    char * mSSID;
    char * mPassword;
    loc_if_req_sender_id_e_type senderId;
    bool mIsInactive;
    inline WIFISubscriber(const AgpsStateMachine* stateMachine,
                         char * ssid, char * password, loc_if_req_sender_id_e_type sender_id) :
        Subscriber(sender_id, stateMachine),
        mSSID(NULL == ssid ? NULL : new char[SSID_BUF_SIZE]),
        mPassword(NULL == password ? NULL : new char[SSID_BUF_SIZE]),
        senderId(sender_id)
    {
      if (NULL != mSSID)
          strlcpy(mSSID, ssid, SSID_BUF_SIZE);
      if (NULL != mPassword)
          strlcpy(mPassword, password, SSID_BUF_SIZE);
      mIsInactive = false;
    }

    virtual bool notifyRsrcStatus(Notification &notification);

    inline virtual void setIPAddresses(uint32_t &v4, char* v6) {}

    inline virtual void setWifiInfo(char* ssid, char* password)
    {
      if (NULL != mSSID)
          strlcpy(ssid, mSSID, SSID_BUF_SIZE);
      else
          ssid[0] = '\0';
      if (NULL != mPassword)
          strlcpy(password, mPassword, SSID_BUF_SIZE);
      else
          password[0] = '\0';
    }

    inline virtual bool waitForCloseComplete() { return true; }

    inline virtual void setInactive() { mIsInactive = true; }
    inline virtual bool isInactive() { return mIsInactive; }

    virtual Subscriber* clone()
    {
        return new WIFISubscriber(mStateMachine, mSSID, mPassword, senderId);
    }
    inline virtual ~WIFISubscriber(){}
};

struct DSSubscriber : public Subscriber {
    bool mIsInactive;
    inline DSSubscriber(const AgpsStateMachine *stateMachine,
                         const int id) :
        Subscriber(id, stateMachine)
    {
        mIsInactive = false;
    }
    inline virtual void setIPAddresses(uint32_t &v4, char* v6) {}
    virtual Subscriber* clone()
    {return new DSSubscriber(mStateMachine, ID);}
    virtual bool notifyRsrcStatus(Notification &notification);
    inline virtual bool waitForCloseComplete() { return true; }
    virtual void setInactive();
    inline virtual bool isInactive()
    { return mIsInactive; }
    inline virtual ~DSSubscriber(){}
    inline virtual char *whoami() {return (char*)"DSSubscriber";}
};

#endif //__LOC_ENG_AGPS_H__