/fbus/fbus_service_manager.c

http://ftk.googlecode.com/ · C · 197 lines · 134 code · 34 blank · 29 comment · 54 complexity · 5ca4f1ccfb6b65df9aec9b26bec94ab5 MD5 · raw file

  1. /*
  2. * File: fbus_service_manager.c
  3. * Author: Li XianJing <xianjimli@hotmail.com>
  4. * Brief: client api used to access service manager.
  5. *
  6. * Copyright (c) 2009 - 2010 Li XianJing <xianjimli@hotmail.com>
  7. *
  8. * Licensed under the Academic Free License version 2.1
  9. *
  10. * This program is free software; you can redistribute it and/or modify
  11. * it under the terms of the GNU General Public License as published by
  12. * the Free Software Foundation; either version 2 of the License, or
  13. * (at your option) any later version.
  14. *
  15. * This program is distributed in the hope that it will be useful,
  16. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  18. * GNU General Public License for more details.
  19. *
  20. * You should have received a copy of the GNU General Public License
  21. * along with this program; if not, write to the Free Software
  22. * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  23. */
  24. /*
  25. * History:
  26. * ================================================================
  27. * 2010-07-25 Li XianJing <xianjimli@hotmail.com> created
  28. *
  29. */
  30. #include "fbus_service_manager.h"
  31. FBusServiceManager* fbus_service_manager_create(void)
  32. {
  33. return fbus_proxy_create(FBUS_SERVICE_MANAGER_NAME);
  34. }
  35. Ret fbus_service_manager_get_nr(FBusServiceManager* thiz, int* nr)
  36. {
  37. Ret ret = RET_FAIL;
  38. FBusParcel* parcel = NULL;
  39. return_val_if_fail(thiz != NULL && nr != NULL, RET_FAIL);
  40. parcel = fbus_proxy_get_parcel(thiz);
  41. return_val_if_fail(parcel != NULL, RET_FAIL);
  42. fbus_parcel_write_int(parcel, FBUS_SERVICE_MANAGER_REQ_GET_NR);
  43. if((ret = fbus_proxy_request(thiz, parcel)) == RET_OK)
  44. {
  45. ret = fbus_parcel_get_int(parcel);
  46. if(ret == RET_OK)
  47. {
  48. *nr = fbus_parcel_get_int(parcel);
  49. }
  50. }
  51. return ret;
  52. }
  53. Ret fbus_service_manager_get(FBusServiceManager* thiz, int i, FBusServiceInfo* info)
  54. {
  55. Ret ret = RET_FAIL;
  56. FBusParcel* parcel = NULL;
  57. return_val_if_fail(thiz != NULL && info != NULL, RET_FAIL);
  58. parcel = fbus_proxy_get_parcel(thiz);
  59. return_val_if_fail(parcel != NULL, RET_FAIL);
  60. fbus_parcel_write_int(parcel, FBUS_SERVICE_MANAGER_REQ_GET);
  61. fbus_parcel_write_int(parcel, i);
  62. if((ret = fbus_proxy_request(thiz, parcel)) == RET_OK)
  63. {
  64. ret = fbus_parcel_get_int(parcel);
  65. if(ret == RET_OK)
  66. {
  67. *info = *(FBusServiceInfo*)fbus_parcel_get_data(parcel, sizeof(FBusServiceInfo));
  68. }
  69. }
  70. return ret;
  71. }
  72. Ret fbus_service_manager_stop(FBusServiceManager* thiz, const char* name)
  73. {
  74. Ret ret = RET_FAIL;
  75. FBusParcel* parcel = NULL;
  76. return_val_if_fail(thiz != NULL && name != NULL, RET_FAIL);
  77. parcel = fbus_proxy_get_parcel(thiz);
  78. return_val_if_fail(parcel != NULL, RET_FAIL);
  79. fbus_parcel_write_int(parcel, FBUS_SERVICE_MANAGER_REQ_STOP);
  80. fbus_parcel_write_string(parcel, name);
  81. if((ret = fbus_proxy_request(thiz, parcel)) == RET_OK)
  82. {
  83. ret = fbus_parcel_get_int(parcel);
  84. }
  85. return ret;
  86. }
  87. Ret fbus_service_manager_start(FBusServiceManager* thiz, const char* name)
  88. {
  89. Ret ret = RET_FAIL;
  90. FBusParcel* parcel = NULL;
  91. return_val_if_fail(thiz != NULL && name != NULL, RET_FAIL);
  92. parcel = fbus_proxy_get_parcel(thiz);
  93. return_val_if_fail(parcel != NULL, RET_FAIL);
  94. fbus_parcel_write_int(parcel, FBUS_SERVICE_MANAGER_REQ_START);
  95. fbus_parcel_write_string(parcel, name);
  96. if((ret = fbus_proxy_request(thiz, parcel)) == RET_OK)
  97. {
  98. ret = fbus_parcel_get_int(parcel);
  99. }
  100. return ret;
  101. }
  102. Ret fbus_service_manager_query(FBusServiceManager* thiz, const char* name, FBusServiceInfo* info)
  103. {
  104. Ret ret = RET_FAIL;
  105. FBusParcel* parcel = NULL;
  106. return_val_if_fail(thiz != NULL && name != NULL && info != NULL, RET_FAIL);
  107. parcel = fbus_proxy_get_parcel(thiz);
  108. return_val_if_fail(parcel != NULL, RET_FAIL);
  109. fbus_parcel_write_int(parcel, FBUS_SERVICE_MANAGER_REQ_QUERY);
  110. fbus_parcel_write_string(parcel, name);
  111. if((ret = fbus_proxy_request(thiz, parcel)) == RET_OK)
  112. {
  113. ret = fbus_parcel_get_int(parcel);
  114. if(ret == RET_OK)
  115. {
  116. *info = *(FBusServiceInfo*)fbus_parcel_get_data(parcel, sizeof(FBusServiceInfo));
  117. }
  118. }
  119. return ret;
  120. }
  121. Ret fbus_service_manager_register(FBusServiceManager* thiz, const char* name, FBusServiceInfo* info)
  122. {
  123. Ret ret = RET_FAIL;
  124. FBusParcel* parcel = NULL;
  125. return_val_if_fail(thiz != NULL && name != NULL && info != NULL, RET_FAIL);
  126. parcel = fbus_proxy_get_parcel(thiz);
  127. return_val_if_fail(parcel != NULL, RET_FAIL);
  128. fbus_parcel_write_int(parcel, FBUS_SERVICE_MANAGER_REQ_REGISTER);
  129. fbus_parcel_write_string(parcel, name);
  130. fbus_parcel_write_string(parcel, FBUS_LOCALHOST);
  131. fbus_parcel_write_int(parcel, getpid());
  132. if((ret = fbus_proxy_request(thiz, parcel)) == RET_OK)
  133. {
  134. ret = fbus_parcel_get_int(parcel);
  135. if(ret == RET_OK)
  136. {
  137. *info = *(FBusServiceInfo*)fbus_parcel_get_data(parcel, sizeof(FBusServiceInfo));
  138. }
  139. }
  140. return ret;
  141. }
  142. Ret fbus_service_manager_unregister(FBusServiceManager* thiz, const char* name)
  143. {
  144. Ret ret = RET_FAIL;
  145. FBusParcel* parcel = NULL;
  146. return_val_if_fail(thiz != NULL && name != NULL, RET_FAIL);
  147. parcel = fbus_proxy_get_parcel(thiz);
  148. return_val_if_fail(parcel != NULL, RET_FAIL);
  149. fbus_parcel_write_int(parcel, FBUS_SERVICE_MANAGER_REQ_UNREGISTER);
  150. fbus_parcel_write_string(parcel, name);
  151. fbus_parcel_write_string(parcel, FBUS_LOCALHOST);
  152. fbus_parcel_write_int(parcel, getpid());
  153. if((ret = fbus_proxy_request(thiz, parcel)) == RET_OK)
  154. {
  155. ret = fbus_parcel_get_int(parcel);
  156. }
  157. return ret;
  158. }
  159. void fbus_service_manager_destroy(FBusServiceManager* thiz)
  160. {
  161. fbus_proxy_destroy(thiz);
  162. return;
  163. }