/*

 * hald-addon-bme.c: bme addon for Mer http://wiki.maemo.org/Mer

 *

 * Copyright (C) 2009 Tom Watson <toggles@gmail.com>

 *

 *  This program is free software: you can redistribute it and/or modify

 *  it under the terms of the GNU General Public License as published by

 *  the Free Software Foundation, either version 3 of the License, or

 *  (at your option) any later version.

 *  

 *  This program is distributed in the hope that it will be useful,

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 *  GNU General Public License for more details.

 *  

 *  You should have received a copy of the GNU General Public License

 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.

 *

 */

#include "mer-bme.h"

#include <errno.h>

#include <fcntl.h>

#include <stdio.h>

#include <unistd.h>

#include <stdarg.h>

#include <stdlib.h>

#include <sys/socket.h>

#include <sys/un.h>

#include <glib/gmain.h>

#include <dbus/dbus-glib-lowlevel.h>

#include <hal/libhal.h>

#include <ctype.h>

#define DEBUGx

#define DEBUG_FILE      "/tmp/hald-addon-bme.log"

/*

 * Basic operation of this program is to connect to hal and dbus in the

 * main function and setup a poll function that is called ~1000ms (default)

 * this will attempt to read the new battery status and update hal / dbus

 * if the socket hasn't connected to the server it will attempt to reconnect.

 */

const char DefaultSocketPath[] = "/tmp/.bmesrv";

const char Handshake[] = "BMentity";

const char BMEPath[] = "/com/nokia/bme/signal";

const char BMEDot[] = "com.nokia.bme.signal";

// battery info

typedef struct {

    uint8 _charger_connected;

    uint8 _battery_full;

    int _battery_percentage;

    uint32 _current;

    uint32 _design;

    uint32 _last_full;

    uint32 _temp_k;

    uint32 _standby_time;

    uint32 _bars_time;

} Battery;

// global variables

typedef struct {

    int _socket;

    const char *_socket_path;

    int _poll_interval;

    int _reconnect_count;

    int _poll_count;

    DBusConnection *_dbus;

    LibHalContext *_hal;

    const char *_udi;

    Battery _battery;

} BMEGlobals;

BMEGlobals Globals;

// function declarations

void close_socket(void);

void print(const char *fmt,...);

/*

 * init routine

 * Set your defaults in here...

 */

void init(void)

{

    memset(&Globals,0,sizeof(Globals));

    // set the defaults..

    Globals._socket=-1;// invalidate socket

    Globals._socket_path=g_strdup(DefaultSocketPath);

    Globals._poll_interval=1000;    // 1000 ms

    Globals._reconnect_count=10;    // attempt reconnect every 10s

    if(getenv("UDI"))

    {

        Globals._udi=g_strdup(getenv("UDI"));  // device id

        print("UDI: %s",Globals._udi);

    }

    else

    {

        Globals._udi=g_strdup("/org/freedesktop/Hal/devices/bme");;

        print("Defaulting to %s - this is not correct",Globals._udi);

    }

}

/*

 * print function for logging

 */

void print(const char *fmt,...)

{

#ifdef DEBUG

    static FILE *fp=0;

    va_list va;

    if(!fp)

#ifdef DEBUG_FILE

        fp=fopen(DEBUG_FILE,"wt");

#else

        fp=stdout;

#endif

    fprintf(fp,"hald-addon-bme: ");

    va_start(va,fmt);

    vfprintf(fp,fmt,va);

    va_end(va);

    fprintf(fp,"\n");

    fflush(0);

#else

    (void)fmt;

#endif

}

/*

 * dbus error handler

 */

void print_dbus_error(const char *text,DBusError *error)

{

    if(text&&error)

    {

        dbus_error_is_set(error);

        print("%s (%s: %s)\n",text,error->name,error->message);

        dbus_error_free(error);

    }

}

/*

 * bme read

 */

int bme_read(void *data,uint32 n)

{

    int i,r,done=0;

    for(i=0;!done&&i<5;++i)

    {

        r=recv(Globals._socket,data,n,0);

        switch(r)

        {

            case 0:

            {

                print("zero length read");

                usleep(1000);

                //read again

                break;

            }

            case -1:

            {

                close_socket();

                // don't break;

            }

            default:

            {

                done=1;

                break;

            }

        }

    }

    return(r);

}

/*

 * connected

 */

int connected(void)

{

    return(Globals._socket>=0);

}

/*

 * close the socket

 */

void close_socket(void)

{

    if(Globals._socket>=0)

    {

        close(Globals._socket);

        Globals._socket=-1;

    }

}

/*

 * connect the BME socket to the server

 */

int connect_socket(const char *path)

{

    int ok=0;

    char ch;

    struct sockaddr_un sock_address;

    if(path)

    {

        memset(&sock_address,0,sizeof(sock_address));

        sock_address.sun_family=PF_UNIX;

        strcpy(sock_address.sun_path,path);

        // create socket

        if((Globals._socket=socket(PF_UNIX,SOCK_STREAM,0))>=0)

        {

            // connect to daemon

            if((connect(Globals._socket,

                        (struct sockaddr *)&sock_address,

                        sizeof(sock_address.sun_family)+strlen(path)))>=0)

            {

                // hand shake

                if(send(Globals._socket,Handshake,strlen(Handshake),0)

                                                        ==strlen(Handshake))

                {

                    if(bme_read(&ch,1)==1)

                    {

                        if(ch=='\n')

                        {

                            // whazzzzup??

                            ok=1;

                        }

                        else

                        {

                            print("Invalid handshake");

                        }

                    }

                    else

                    {

                        print("Error reading handshake");

                    }

                }

                else

                {

                    print("Error sending handshake");

                }

            }

            else

            {

                print("Cannot connect to BME server (%s)",path);

            }

            // if we failed we need to close the socket..

            if(!ok)

            {

                close_socket();

            }

        }

        else

        {

            print("Cannot create socket");

        }

    }

    else

    {

        print("Invalid path");

    }

    return(ok);

}

/*

 * set hal bool

 */

void hal_bool(const char *name,uint8 b)

{

    libhal_device_set_property_bool(Globals._hal,

                                    Globals._udi,

                                    name,

                                    b?TRUE:FALSE,

                                    0);

}

/*

 * set hal int 

 */

void hal_int(const char *name,int i)

{

    libhal_device_set_property_int(Globals._hal,Globals._udi,name,i,0);

}

/*

 * set hal string 

 */

void hal_string(const char *name,const char *string)

{

    libhal_device_set_property_string(Globals._hal,Globals._udi,name,string,0);

}

/*

 * battery full signal

 */

void battery_full(void)

{

    DBusMessage *msg;

    if(Globals._battery._battery_full)

    {

        msg=dbus_message_new_signal(BMEPath,

                                    BMEDot,

                                    "battery_full");

        dbus_connection_send(Globals._dbus,msg,0);

        dbus_connection_flush(Globals._dbus);

        dbus_message_unref(msg);

        hal_string("battery.charge_level.capacity_state","full");

    }

    else

    {

        // this isn't called all the time, will only go from full to ok

        // need to adjust..

        hal_string("battery.charge_level.capacity_state",

                   Globals._battery._battery_percentage>25?"ok":"low");

    }

}

/*

 * charger connected

 */

void charger_connected(void)

{

    DBusMessage *msg=dbus_message_new_signal(BMEPath,

                                             BMEDot,

                                             Globals._battery._charger_connected

                                                 ?"charger_connected"

                                                 :"charger_disconnected");

    DBusMessage *charging;

    char *ptr="charger_charging_off";

    // emulates nokias bme, if charger connected report charging or full

    if(Globals._battery._charger_connected)

    {

        ptr=Globals._battery._battery_full?"battery_full":"charger_charging_on";

    }

    charging=dbus_message_new_signal(BMEPath,

                                     BMEDot,

                                     ptr);

    dbus_connection_send(Globals._dbus,msg,0);

    dbus_connection_send(Globals._dbus,charging,0);

    dbus_connection_flush(Globals._dbus);

    dbus_message_unref(msg);

    dbus_message_unref(charging);

    //update hal

    hal_bool("battery.rechargeable.is_charging",

             Globals._battery._charger_connected);

    hal_bool("battery.rechargeable.is_discharging",

             !Globals._battery._charger_connected);

}

/*

H

 * update_percentage()

 */

void update_percentage(void)

{

    hal_int("battery.charge_level.current",Globals._battery._current);

    hal_int("battery.reporting.current",Globals._battery._current);

    hal_int("battery.charge_level.percentage",

            Globals._battery._battery_percentage);

    if(Globals._battery._current>Globals._battery._last_full)

    {

        Globals._battery._last_full=Globals._battery._current;

        hal_int("battery.charge_level.last_full",Globals._battery._last_full);

        hal_int("battery.reporing.last_full",Globals._battery._last_full);

    }

}

/*

 * update_time()

 */

void update_time(void)

{

    DBusMessage *msg=dbus_message_new_signal(BMEPath,BMEDot,"battery_timeleft");

    if(msg)

    {

        dbus_message_append_args(msg,

                                 DBUS_TYPE_INT32,

                                 &Globals._battery._standby_time,

                                 DBUS_TYPE_INT32,

                                 &Globals._battery._bars_time);

        dbus_connection_send(Globals._dbus,msg,0);

        dbus_connection_flush(Globals._dbus);

        dbus_message_unref(msg);

    }

    else

    {

        print("cannot create message");

    }

}

/*

 * read the battery information

 */

void get_battery_info(void)

{

    uint8 ok=1;

    BMERequest req;

    struct emsg_bme_battery_info_reply info;

    struct emsg_bme_battery_curr_reply curr;

    struct emsg_bme_bulk0_reply bulk0;

    struct emsg_bme_bulk1_reply bulk1;

    if(ok&&connected())

    {

        ok=0;

        memset(&req,0,sizeof(req));

        req._type=EM_BATTERY_INFO_REQ;

        req._flags=-1;

        if(write(Globals._socket,&req,sizeof(req))==sizeof(req))

        {

            if(bme_read(&info,sizeof(info))==sizeof(info))

            {

                ok=1;

                if(Globals._battery._design!=info._capacity)

                {

                    Globals._battery._design=info._capacity;

                    hal_int("battery.reporting.design",

                            Globals._battery._design);

                }

                if(Globals._battery._temp_k!=info._temp_k)

                {

                    Globals._battery._temp_k=info._temp_k;

                }

            }

            else

            {

                print("Invalid info read");

            }

        }

        else

        {

            print("Invalid info write");

        }

    }

    if(ok&&connected())

    {

        ok=0;

        memset(&req,0,sizeof(req));

        req._type=EM_BATTERY_CURR_REQ;

        req._flags=-1;

        if(write(Globals._socket,&req,sizeof(req))==sizeof(req))

        {

            if(bme_read(&curr,sizeof(curr))==sizeof(curr))

            {

                ok=1;

                // prevent div by zero

                if(Globals._battery._design)

                {

                    // battery capacity changed.. ?

                    if(Globals._battery._current*100/Globals._battery._design

                        !=Globals._battery._battery_percentage)

                    {

                        // force update

                        Globals._battery._current=0;

                    }

                }

                if(Globals._battery._current!=curr._capacity)

                {

                    Globals._battery._current=curr._capacity;

                    // prevent div by zero

                    if(Globals._battery._design)

                    {

                        Globals._battery._battery_percentage

                              =Globals._battery._current*100

                                  /Globals._battery._design;

                        // update % and current..

                        update_percentage();

                    }

                }

            }

            else

            {

                print("Invalid curr read");

            }

        }

        else

        {

            print("Invalid curr write");

        }

    }

    if(ok&&connected())

    {

        ok=0;

        memset(&req,0,sizeof(req));

        req._type=BULK0_REQ;

        req._flags=-1;

        if(write(Globals._socket,&req,sizeof(req))==sizeof(req))

        {

            if(bme_read(&bulk0,sizeof(bulk0))==sizeof(bulk0))

            {

                ok=1;

                // update time

                bulk0._n_bars*=bulk0._time_per_bar;

                bulk0._n_bars/=60;

                bulk0._standby_time/=60;

                if(Globals._battery._standby_time!=bulk0._standby_time

                 ||Globals._battery._bars_time!=bulk0._n_bars)

                {

                    Globals._battery._standby_time=bulk0._standby_time;

                    Globals._battery._bars_time=bulk0._n_bars;

                    update_time();

                }

            }

            else

            {

                print("Invalid bulk0 read");

            }

        }

        else

        {

            print("Invalid bulk0 write");

        }

    }

    // if we failed, disconnect

    if(ok&&connected())

    {

        ok=0;

        memset(&req,0,sizeof(req));

        req._type=BULK1_REQ;

        req._flags=-1;

        if(write(Globals._socket,&req,sizeof(req))==sizeof(req))

        {

            if(bme_read(&bulk1,sizeof(bulk1))==sizeof(bulk1))

            {

                ok=1;

                // charging event?

                if(Globals._battery._charger_connected!=bulk1._charger_type)

                {

                    Globals._battery._charger_connected=bulk1._charger_type;

                    charger_connected();

                }

                // check for full battery event

                if(Globals._battery._battery_full!=bulk1._battery_full)

                {

                    Globals._battery._battery_full=bulk1._battery_full;

                    battery_full();

                }

            }

            else

            {

                print("Invalid bulk1 read");

            }

        }

        else

        {

            print("Invalid bulk1 write");

        }

    }

    // if we failed, disconnect

    if(!ok)

    {

        close_socket();

    }

}

/*

 * poll routine

 */

gboolean poll_socket(gpointer data)

{

    (void)data;

    // inc poll count

    ++Globals._poll_count;

    // valid socket?

    if(Globals._socket>=0)

    {

        get_battery_info();

    }

    else

    {

        // attempt to reconnect the socket if it's time

        if(Globals._poll_count>Globals._reconnect_count)

        {

            // reset poll count

            Globals._poll_count=0;

            connect_socket(Globals._socket_path);

        }

    }

    return(TRUE);

}

/*

 * claim the hal interface

 */

int claim_interface(void)

{

    int claimed;

    DBusError error;

    claimed=libhal_device_claim_interface(Globals._hal,

                                          Globals._udi,

                                          Globals._udi,

                                          "",  // shoudl be xml in here

                                          &error);

    if(claimed)

    {

        if(!libhal_device_addon_is_ready(Globals._hal,Globals._udi,&error))

        {

            print("Unable to assert ready");

        }

    }

    else

    {

        print("cannot claim interface");

    }

    return(claimed);

}

/*

 * main routine

 */

int main(int argc,char *argv[])

{

    DBusError error;

    GMainLoop *gmain=0;

    init();

    dbus_error_init(&error);

    if((Globals._dbus=dbus_bus_get(DBUS_BUS_SYSTEM,&error))!=0)

    {

        if((Globals._hal=libhal_ctx_new())!=0)

        {

            if(libhal_ctx_set_dbus_connection(Globals._hal,Globals._dbus))

            {

                if((Globals._hal=libhal_ctx_init_direct(&error))!=0)

                {

                    if(claim_interface())

                    {

                        // connect the socket

                        connect_socket(Globals._socket_path);

                        // setup main loop

                        dbus_connection_setup_with_g_main(Globals._dbus,0);

                        dbus_connection_set_exit_on_disconnect(Globals._dbus,0);

                        gmain=g_main_loop_new(0,FALSE);

                        // add poll callback

                        g_timeout_add(Globals._poll_interval,poll_socket,0);

                        // execute

                        g_main_loop_run(gmain);

                    }

                    else

                    {

                        print("Cannot claim interface");

                    }

                }

                else

                {

                    print_dbus_error("CTX init",&error);

                }

            }

            else

            {

                print_dbus_error("CTX dbus",&error);

            }

        }

        else

        {

            print_dbus_error("CTX",&error);

        }

    }

    else

    {

        print_dbus_error("DBUS",&error);

    }

    if(Globals._hal)

    {

        libhal_ctx_shutdown(Globals._hal,&error);

        libhal_ctx_free(Globals._hal);

    }

    if(Globals._dbus)

    {

        dbus_connection_unref(Globals._dbus);

    }

    return(0);

}