path: root/NativeLauncher/src/waiter/waiter.cc

#include <poll.h>

#ifndef NO_TIZEN
#include <launchpad.h>
#include <aul.h>
#endif

#include <memory>
#include <vector>
#include <map>
#include <poll.h>

#include <iostream>

#include "waiter.h"
#include "log.h"

namespace dotnet {
namespace runtime {

struct FdHandler
{
  pollfd *info;
  Receiver receiver;
};

static volatile bool Waiting_;
static std::vector<pollfd> Fdlist_;
static std::map<int, FdHandler> Handlers_;
static Waiter::AppInfo AppInfo_;

void Waiter::OnPrepared()
{
  if (!context.Prepare())
  {
    _DBG("Fail to Prepare...");
  }
}

void Waiter::OnRequested(const AppInfo& info)
{
  // do some job on user id is still system

  if (!context.Request())
  {
    _DBG("Fail to Request...");
  }
}

void Waiter::OnExecuted(const char *path, const char *app_root, int argc, char *argv[])
{
  if (!context.Execute(path, app_root, argc, argv))
  {
    _DBG("Fail to Execute...");
  }
}

void Waiter::OnWaiting()
{
  // Start the loop
  Waiting_ = true;

  _DBG("start polling...");
  while (Waiting_)
  {
    if (poll(Fdlist_.data(), Fdlist_.size(), -1) < 0)
      continue;

    for (auto &p : Fdlist_)
    {
      if ( (p.revents | POLLIN) != 0 )
        Handlers_[p.fd].receiver(p.fd);
    }
  }
  _DBG("end polling...");
}

void Waiter::Stop()
{
  // Stop the loop

  Waiting_ = false;
}


void Waiter::RegisterFd(int fd, Receiver receiver)
{
  // register fd should be caught in event loop

  _DBG("Register fd %d", fd);

  pollfd info;
  info.fd = fd;
  info.events = POLLIN;
  info.revents = 0;

  FdHandler handler;
  Fdlist_.push_back(info);
  handler.info = &Fdlist_.back(); 
  handler.receiver = receiver;

  Handlers_[fd] = handler;
}

void Waiter::DeregisterFd(int fd)
{
  // deregister fd should be caught in event loop
  
  pollfd *info = Handlers_[fd].info;
  Fdlist_.erase(Fdlist_.begin() - (info - &Fdlist_.front()));
  Handlers_.erase(fd);
}

int Waiter::WaitToLaunching(int argc, char *argv[])
{
#ifndef NO_TIZEN
  auto on_create = [](bundle *extra, int type, void *user_data)
  {
    _DBG("on_create..."); // XXX
    Waiter* waiter = static_cast<Waiter*>(user_data);
    waiter->OnPrepared();
  };

  auto on_launch = [](int argc, char **argv, const char *app_path,
      const char *appid, const char *pkgid,
      const char *pkg_type, void *user_data) -> int
  {
    _DBG("on_launch..."); // XXX
    Waiter* waiter = static_cast<Waiter*>(user_data);

    _DBG ("app path : %s", app_path);
    _DBG ("app id : %s", appid);
    _DBG ("pkg id : %s", pkgid);
    _DBG ("pkg type : %s", pkg_type);

    AppInfo info = {
      AppPath : app_path,
      AppId : appid,
      PkgId : pkgid,
      PkgType : pkg_type
    };

    waiter->OnRequested(info);
    return 0;
  };

  auto on_terminate = [](int argc, char **argv, void *user_data) -> int
  {
    _DBG("on_terminate..."); // XXX
    
    string app_root(aul_get_app_root_path());
    Waiter* waiter = static_cast<Waiter*>(user_data);
    waiter->OnExecuted(argv[0], app_root.c_str(), argc, argv);
    return 0;
  };

  auto on_start_loop = [](void *user_data)
  {
    _DBG("on_start_loop..."); // XXX
    Waiter* waiter = static_cast<Waiter*>(user_data);
    waiter->OnWaiting();
  };

  auto on_quit_loop = [](void *user_data)
  {
    _DBG("on_quit_loop..."); // XXX
    Waiter* waiter = static_cast<Waiter*>(user_data);
    waiter->Stop();
  };

  auto on_add_fd = [](void *user_data, int fd, loader_receiver_cb receiver)
  {
    _DBG("on_add_fd..."); // XXX
    Waiter* waiter = static_cast<Waiter*>(user_data);
    waiter->RegisterFd(fd, receiver);
  };

  auto on_remove_fd = [](void *user_data, int fd)
  {
    _DBG("on_remove_fd..."); // XXX
    Waiter* waiter = static_cast<Waiter*>(user_data);
    waiter->DeregisterFd(fd);
  };

  _DBG("launcher wait..."); // XXX
  loader_lifecycle_callback_s callbacks = {
    .create = on_create,
    .launch = on_launch,
    .terminate = on_terminate
  };

	loader_adapter_s adapter = {
		.loop_begin = on_start_loop,
		.loop_quit = on_quit_loop,
		.add_fd = on_add_fd,
		.remove_fd = on_remove_fd
	};

  return launchpad_loader_main(argc, argv, &callbacks, &adapter, this);
#else
  if (argc < 2)
  {
    _DBG("not enough args : %d", argc);
    return -1;
  }
  _DBG("argv[1] = %s", argv[1]);
  std::string app_path(argv[1]);
  std::string app_root;
  auto pos = app_path.find_last_of('/');
  if (pos != std::string::npos)
    app_root = app_path.substr(0, pos);
  else
    app_root = ".";

  this->OnPrepared();
  AppInfo info = {
    AppPath : argv[1],
    AppId : "",
    PkgId : "",
    PkgType : ""
  };
  this->OnRequested(info);
  this->OnExecuted(app_path.c_str(), app_root.c_str(), argc, argv);
#endif
}

void Waiter::SetContext(WaiterContext ctx)
{
  context = ctx;
}

WaiterContext::WaiterContext()
{
  Step = Status::Started;
}

bool WaiterContext::Prepare()
{
  if (Step == Status::Started && Prepared != nullptr && Prepared(Data) == 0)
  {
    Step = Status::Prepared;
    return true;
  }
  return false;
}

bool WaiterContext::Request()
{
  if (Step == Status::Prepared && Requested != nullptr && Requested(Data) == 0)
  {
    Step = Status::Requested;
    return true;
  }
  return false;
}

bool WaiterContext::Execute(const char *path, const char *app_root, int argc, char *argv[])
{
  if (Step == Status::Requested && Executed != nullptr &&
      Executed(path, app_root, argc, argv, Data) == 0)
  {
    Step = Status::Executed;
    return true;
  }
  return false;
}

}  // namespace runtime
}  // namespace dotnet

using dotnet::runtime::Waiter;
using dotnet::runtime::WaiterContext;

static Waiter waiter;

void register_launching_callback(prepared_callback prepared,
    requested_callback requested, executed_callback executed, void *data)
{
  WaiterContext context;
  context.Prepared = prepared;
  context.Requested = requested;
  context.Executed = executed;
  context.Data = data;

  waiter.SetContext(context);
}

void wait_for_launching(int argc, char *argv[])
{
  _DBG("wait_for_launching...");

  waiter.WaitToLaunching(argc, argv);
}