private Ice.AsyncResult<minie.irpc.Callback_AppService_grant_privilige> begin_grant_privilige(minie.irpc.cm_user_friend_rpc friend, minie.irpc.cm_node_rpc room, string valid_thru, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
 {
     checkAsyncTwowayOnly__(__grant_privilige_name);
     IceInternal.TwowayOutgoingAsync<minie.irpc.Callback_AppService_grant_privilige> result__ =  getTwowayOutgoingAsync<minie.irpc.Callback_AppService_grant_privilige>(__grant_privilige_name, grant_privilige_completed__, cookie__);
     if(cb__ != null)
     {
         result__.whenCompletedWithAsyncCallback(cb__);
     }
     try
     {
         result__.prepare(__grant_privilige_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
         IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
         os__.writeObject(friend);
         os__.writeObject(room);
         os__.writeString(valid_thru);
         os__.writePendingObjects();
         result__.endWriteParams();
         result__.invoke();
     }
     catch(Ice.Exception ex__)
     {
         result__.abort(ex__);
     }
     return result__;
 }

 public int revoke_privilige(minie.irpc.cm_friend_privilege_rpc privilege)
 {
     return revoke_privilige(privilege, Ice.ObjectImpl.defaultCurrent);
 }

 private void check_cellphone_completed__(Ice.AsyncResult r__, minie.irpc.Callback_AppAuth_check_cellphone cb__, Ice.ExceptionCallback excb__)
 {
     bool ret__;
     try
     {
         ret__ = end_check_cellphone(r__);
     }
     catch(Ice.Exception ex__)
     {
         if(excb__ != null)
         {
             excb__(ex__);
         }
         return;
     }
     if(cb__ != null)
     {
         cb__(ret__);
     }
 }

 public int refuse_friend_req(minie.irpc.cm_friend_request_rpc req)
 {
     return refuse_friend_req(req, Ice.ObjectImpl.defaultCurrent);
 }

 public minie.irpc.cm_friend_privilege_rpc grant_privilige(minie.irpc.cm_user_friend_rpc friend, minie.irpc.cm_node_rpc room, string valid_thru)
 {
     return grant_privilige(friend, room, valid_thru, Ice.ObjectImpl.defaultCurrent);
 }

 public int update_user_info(minie.irpc.cm_user_rpc userInfo)
 {
     return update_user_info(userInfo, Ice.ObjectImpl.defaultCurrent);
 }

 public int discard_friend_request(minie.irpc.cm_friend_request_rpc request)
 {
     return discard_friend_request(request, Ice.ObjectImpl.defaultCurrent);
 }

 public Ice.AsyncResult<minie.irpc.Callback_AppService_revoke_privilige> begin_revoke_privilige(minie.irpc.cm_friend_privilege_rpc privilege, _System.Collections.Generic.Dictionary<string, string> ctx__)
 {
     return begin_revoke_privilige(privilege, ctx__, true, false, null, null);
 }

 public Ice.AsyncResult begin_refuse_friend_req(minie.irpc.cm_friend_request_rpc req, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
 {
     return begin_refuse_friend_req(req, ctx__, true, false, cb__, cookie__);
 }

 private void update_user_info_completed__(Ice.AsyncResult r__, minie.irpc.Callback_AppService_update_user_info cb__, Ice.ExceptionCallback excb__)
 {
     int ret__;
     try
     {
         ret__ = end_update_user_info(r__);
     }
     catch(Ice.Exception ex__)
     {
         if(excb__ != null)
         {
             excb__(ex__);
         }
         return;
     }
     if(cb__ != null)
     {
         cb__(ret__);
     }
 }

 private void logout_completed__(minie.irpc.Callback_BaseService_logout cb__)
 {
     if(cb__ != null)
     {
         cb__();
     }
 }

 private void revoke_privilige_completed__(Ice.AsyncResult r__, minie.irpc.Callback_AppService_revoke_privilige cb__, Ice.ExceptionCallback excb__)
 {
     int ret__;
     try
     {
         ret__ = end_revoke_privilige(r__);
     }
     catch(Ice.Exception ex__)
     {
         if(excb__ != null)
         {
             excb__(ex__);
         }
         return;
     }
     if(cb__ != null)
     {
         cb__(ret__);
     }
 }

 public Ice.AsyncResult<minie.irpc.Callback_AppService_update_user_info> begin_update_user_info(minie.irpc.cm_user_rpc userInfo)
 {
     return begin_update_user_info(userInfo, null, false, false, null, null);
 }

 private void login_app_completed__(Ice.AsyncResult r__, minie.irpc.Callback_AppAuth_login_app cb__, Ice.ExceptionCallback excb__)
 {
     minie.irpc.AppServicePrx ret__;
     try
     {
         ret__ = end_login_app(r__);
     }
     catch(Ice.Exception ex__)
     {
         if(excb__ != null)
         {
             excb__(ex__);
         }
         return;
     }
     if(cb__ != null)
     {
         cb__(ret__);
     }
 }