/*
  *

  *   Copyright (C) 2020, University of the Basque Country (UPV/EHU)

  *
  *  Contact for licensing options: <licensing-mcpttclient(at)mcopenplatform(dot)com>
  *
  *  This file is part of MCOP MCPTT Client
  *
  *  This 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 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, write to the Free Software Foundation, Inc.,
  *  59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  */
 
 package org.mcopenplatform.muoapi;
 
 import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
 import android.content.IntentFilter;
 import android.content.ServiceConnection;
 import android.net.Uri;
 import android.os.Binder;
 import android.os.Handler;
 import android.os.IBinder;
 import android.os.Looper;
 import android.os.RemoteException;

 import android.support.annotation.NonNull;
 import android.support.annotation.Nullable;

 import android.util.Log;
 
 import org.doubango.ngn.BuildConfig;
 import org.doubango.ngn.NgnEngine;
 import org.doubango.ngn.datatype.affiliation.affiliationcommand.CommandList;
 import org.doubango.ngn.datatype.affiliation.pidf.AffiliationType;
 import org.doubango.ngn.datatype.affiliation.pidf.Presence;
 import org.doubango.ngn.datatype.affiliation.pidf.StatusType;
 import org.doubango.ngn.datatype.affiliation.pidf.Tuple;

 import org.doubango.ngn.datatype.ms.cms.mcpttUserProfile.McpttUserProfile;
 import org.doubango.ngn.datatype.ms.gms.ns.list_service.ListServiceType;

 import org.doubango.ngn.events.NgnEventArgs;
 import org.doubango.ngn.events.NgnRegistrationEventArgs;
 import org.doubango.ngn.media.NgnMediaType;
 import org.doubango.ngn.services.INgnSipService;
 import org.doubango.ngn.services.affiliation.IMyAffiliationService;
 import org.doubango.ngn.sip.NgnAVSession;
 import org.doubango.ngn.sip.NgnSipPrefrences;
 import org.doubango.ngn.utils.NgnUriUtils;

 import org.mcopenplatform.muoapi.datatype.Client;
 import org.mcopenplatform.muoapi.datatype.ClientSIM;

 import org.mcopenplatform.muoapi.datatype.error.Constants;
 import org.mcopenplatform.muoapi.datatype.group.GroupAffiliation;
 import org.mcopenplatform.muoapi.datatype.group.GroupInfo;
 import org.mcopenplatform.muoapi.managerIapi.EngineIapi;

 import org.mcopenplatform.muoapi.managerIapi.ManagerConfigurationService;
 import org.mcopenplatform.muoapi.managerIapi.ManagerMBMSGroupCom;
 import org.mcopenplatform.muoapi.managerIapi.ManagerSimService;

 import org.mcopenplatform.muoapi.session.ManagerSessions;
 import org.mcopenplatform.muoapi.utils.Utils;
 

 import java.io.Serializable;

 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 

 import static org.mcopenplatform.muoapi.ManagerClientUtils.TypeParticipant.DISPLAY_NAME;
 import static org.mcopenplatform.muoapi.ManagerClientUtils.TypeParticipant.TYPE;
 import static org.mcopenplatform.muoapi.ManagerClientUtils.TypeParticipant.URI;

 import static org.mcopenplatform.muoapi.utils.Utils.checkGroupIsExist;
 import static org.mcopenplatform.muoapi.utils.Utils.isAffiliatedGroup;
 import static org.mcopenplatform.muoapi.utils.Utils.isAffiliatingGroup;
 import static org.mcopenplatform.muoapi.utils.Utils.isDeaffiliatedGroup;
 import static org.mcopenplatform.muoapi.utils.Utils.isDeaffiliatingGroup;
 import static org.mcopenplatform.muoapi.utils.Utils.validationCallType;
 
 public class ManagerClient implements
         IMyAffiliationService.OnAffiliationServiceListener
         , ManagerSessions.OnManagerSessionListener

         , org.doubango.ngn.services.cms.IMyCMSService.OnAuthenticationListener
         , org.doubango.ngn.services.cms.IMyCMSService.OnGetMcpttUserProfileListener
         , org.doubango.ngn.services.cms.IMyCMSService.OnGetMcpttServiceConfListener
         , org.doubango.ngn.services.cms.IMyCMSService.OnGetMcpttUEConfigurationListener
         , org.doubango.ngn.services.cms.IMyCMSService.OnGetMcpttUEInitialConfigurationListener
         , org.doubango.ngn.services.cms.IMyCMSService.OnStableListener
         , org.doubango.ngn.services.gms.IMyGMSService.OnGMSListener
         , org.doubango.ngn.services.cms.IMyCMSService.OnCMSPrivateContactsListener

         , INgnSipService.OnAuthenticationListener
 {
     private final static String TAG = org.mcopenplatform.muoapi.utils.Utils.getTAG(ManagerClient.class.getCanonicalName());
     private ArrayList<Long> sessionsID;

     private Client client;

     private IBinder iBinder;
     private IMCOPCallback mMCOPCallback;
     private NgnEngine ngnEngine;
     private INgnSipService ngnSipService;
     private IMyAffiliationService myAffiliationService;

     private org.doubango.ngn.services.cms.IMyCMSService myCMSService;
     private org.doubango.ngn.services.gms.IMyGMSService myGMSService;

     private ManagerSessions managerSessions;
     private Context context;
     private ManagerClient thisInstance;
     private BroadcastReceiver mSipBroadcastRecvRegister;
     private ServiceConnection mConnectionSimService;
     private EngineIapi engineIapi;

     private String connectivityPluginPackageService;
     private String connectivityPluginPackageMain;
     private String simPluginPackageService;
     private String simPluginPackageMain;
     private String configurationPluginPackageService;
     private String configurationPluginPackageMain;
     private String mbmsPluginPackageService;
     private String mbmsPluginPackageMain;
 

     private static int ERROR_RETURN_CODE = -1;
     private static int SUCCESS_RETURN_CODE = 0;
 

     public ManagerClient(Context context
     ,String connectivityPluginPackageService
     ,String connectivityPluginPackageMain
     ,String simPluginPackageService
     ,String simPluginPackageMain
     ,String configurationPluginPackageService
     ,String configurationPluginPackageMain
     ,String mbmsPluginPackageService
     ,String mbmsPluginPackageMain
     ) {

         this.context=context;

         this.connectivityPluginPackageService = connectivityPluginPackageService;
         this.connectivityPluginPackageMain = connectivityPluginPackageMain;
         this.simPluginPackageService = simPluginPackageService;
         this.simPluginPackageMain = simPluginPackageMain;
         this.configurationPluginPackageService = configurationPluginPackageService;
         this.configurationPluginPackageMain = configurationPluginPackageMain;
         this.mbmsPluginPackageService = mbmsPluginPackageService;
         this.mbmsPluginPackageMain = mbmsPluginPackageMain;

         engineIapi=EngineIapi.getInstance();
         ngnEngine=NgnEngine.getInstance();
         thisInstance=this;

     }
     private ManagerClient getThisInstance(){
         return this;

     }

     private void selectActiveProfile(){
            engineIapi.getConfigurationService().setOnConfigurationServiceListener(new ManagerConfigurationService.OnConfigurationServiceListener() {
                @Override
                public void onConfigurationProfile(String profile) {
                    if(profile!=null && !profile.isEmpty()){
                        if(getThisInstance().importProfileMCOP2(profile)){
                            if(BuildConfig.DEBUG)Log.d(TAG,"Correct selectActiveProfile");
                        }else{
                            if(BuildConfig.DEBUG)Log.w(TAG,"No correct selectActiveProfile");
                        }
                    }
                }
 
                @Override
                public void onErroConfigurationProfile(String error) {
                 if(BuildConfig.DEBUG)Log.e(TAG,"Error in Configuration Profile: "+error);
                }
            });

 
     }

     private void initEngineService(){

         Log.d(TAG,"Initialize MCOP Service");

 
         selectActiveProfile();
         initMBMSEvent();
         configureGetParameterSIM();
         if(ngnEngine.start()){
             Log.d(TAG,"MCOP Service: Started");
             ngnSipService=ngnEngine.getSipService();
             ngnSipService.setOnAuthenticationListener(this);
 
             myAffiliationService=ngnEngine.getAffiliationService();
             myCMSService=ngnEngine.getCMSService();
             if(myCMSService!=null){
                 myCMSService.setOnCMSPrivateContactsListener(this);
             }
             myGMSService=ngnEngine.getGMSService();
             if(myGMSService!=null){
                 myGMSService.setOnGMSListener(thisInstance);
             }
             //Start Manager session
             managerSessions=ManagerSessions.getInstance(context);
             managerSessions.setOnManagerSessionListener(this);
             sessionsID=new ArrayList<>();
             //Affiliation
             ngnEngine.getAffiliationService().setOnAffiliationServiceListener(thisInstance);
         }else{
             Log.e(TAG,"MCOP Service: Error");
         }
         if(mSipBroadcastRecvRegister==null){
             if(BuildConfig.DEBUG)Log.d(TAG,"SipBroadcastRecvRegister execute");
             mSipBroadcastRecvRegister = new BroadcastReceiver() {
                 @Override
                 public void onReceive(Context context, Intent intent) {
                     final String action = intent.getAction();
 
                     // Registration Event
                     if(NgnRegistrationEventArgs.ACTION_REGISTRATION_EVENT.equals(action)){
                         NgnRegistrationEventArgs args = intent.getParcelableExtra(NgnEventArgs.EXTRA_EMBEDDED);
                         if(args == null){
                             Log.e(TAG, "Invalid event arguments");
                             return;
                         }
                         switch(args.getEventType()){
                             case REGISTRATION_NOK:
                                 if(BuildConfig.DEBUG)Log.d(TAG,"REGISTRATION_NOK");
                                 sendErrorLoginEvent(Constants.ConstantsErrorMCOP.LoginEventError.CCVII);
                                 sendLoginEvent(false);
                                 break;
                             case UNREGISTRATION_OK:
                                 if(BuildConfig.DEBUG)Log.d(TAG,"UNREGISTRATION_OK");
                                 sendUnLoginEvent(true);
                                 break;
                             case REGISTRATION_OK:
                                 if(BuildConfig.DEBUG)Log.d(TAG,"REGISTRATION_OK");
                                 //Send affiliation from groups implicit
                                 affiliationImplicitGroups();
                                 sendLoginEvent(true);
                                 break;
                             case REGISTRATION_INPROGRESS:
                                 if(BuildConfig.DEBUG)Log.d(TAG,"REGISTRATION_INPROGRESS");
                                 //TODO:Logical for register
                                 break;
                             case UNREGISTRATION_INPROGRESS:
                                 if(BuildConfig.DEBUG)Log.d(TAG,"UNREGISTRATION_INPROGRESS");
                                 //TODO:Logical for register
                                 break;
                             case UNREGISTRATION_NOK:
                                 if(BuildConfig.DEBUG)Log.d(TAG,"UNREGISTRATION_NOK");
                                 sendErrorUnLoginEvent(Constants.ConstantsErrorMCOP.UnLoginEventError.CCVII);
                                 sendUnLoginEvent(false);
                                 break;

                         }
                     }

                 }
             };
             final IntentFilter intentFilter = new IntentFilter();
             intentFilter.addAction(NgnRegistrationEventArgs.ACTION_REGISTRATION_EVENT);
             context.registerReceiver(mSipBroadcastRecvRegister, intentFilter);

         }else{

             if(BuildConfig.DEBUG)Log.e(TAG,"SipBroadcastRecvRegister isn´t null");

         }

     }
 
     private void showInfoPackageName(){
         String callingApp = context.getPackageManager().getNameForUid(Binder.getCallingUid());
         if(BuildConfig.DEBUG)Log.d(TAG,"callingApp: "+callingApp+"\nuid: "+Binder.getCallingUid() );
     }
 
 
     protected IBinder startManagerClient(boolean reBind){
         if(BuildConfig.DEBUG)Log.d(TAG,"startManagerClient");

         //Start and Binder to services
         if(!engineIapi.isStarted()){

             engineIapi.start(context
             ,connectivityPluginPackageService
             ,connectivityPluginPackageMain
             ,simPluginPackageService
             ,simPluginPackageMain
             ,configurationPluginPackageService
             ,configurationPluginPackageMain
             ,mbmsPluginPackageService
             ,mbmsPluginPackageMain
             );

         }else{

             if(BuildConfig.DEBUG)Log.w(TAG,"EngineIapi started");

         }

         //Start NgnEngine
         if(!ngnEngine.isStarted()){
             if(BuildConfig.DEBUG)Log.d(TAG,"Engine is no started");
         }else{
             if(BuildConfig.DEBUG)Log.e(TAG,"Engine started");
             ngnEngine.stop();
         }
         initEngineService();
 
 

         if(!reBind)

         iBinder=new IMCOPsdk.Stub() {
             @Override
             public String getMCOPCapabilities() throws RemoteException {

                 showInfoPackageName();

                 return null;
             }
 
 

             @Override

             public int login() throws RemoteException {

                 showInfoPackageName();

                 int  result=ERROR_RETURN_CODE;

                 if(ngnEngine.isStarted() && ngnSipService!=null && ngnSipService.isRegistered()){

                     sendErrorLoginEvent(Constants.ConstantsErrorMCOP.LoginEventError.CCV);

                     result=ERROR_RETURN_CODE;

                 }else{

                     if(myCMSService!=null){
                         myCMSService.setOnAuthenticationListener(thisInstance);
                         myCMSService.setOnGetMcpttUserProfileListener(thisInstance);
                         myCMSService.setOnGetMcpttServiceConfListener(thisInstance);
                         myCMSService.setOnStableListener(thisInstance);
                         myCMSService.setOnGetMcpttUEConfigurationListener(thisInstance);
                         myCMSService.setOnGetMcpttUEInitConfigurationListener(thisInstance);

                         result=myCMSService.initConfiguration(context)?SUCCESS_RETURN_CODE:ERROR_RETURN_CODE;

                     }

                 }

                 return result;
             }
 
             @Override

             public int logout () throws RemoteException {

                 showInfoPackageName();
                 if(BuildConfig.DEBUG)Log.d(TAG,"Initialize unLogin Process");
                 if(ngnSipService!=null && ngnSipService.isRegistered()){

                     ngnSipService.unRegister();

                     return SUCCESS_RETURN_CODE;

                 }else{

                     if(BuildConfig.DEBUG)Log.e(TAG,"Device unregistered");

                     sendErrorUnLoginEvent(Constants.ConstantsErrorMCOP.UnLoginEventError.CCV);
                 }

                 return ERROR_RETURN_CODE;

             }
 
             @Override

             public int authorizeUser(String url) throws RemoteException {

                 showInfoPackageName();

                 int  result=ERROR_RETURN_CODE;

                 Uri uri=null;
                 try {
                     if(url==null || url.trim().isEmpty() || (uri=Uri.parse(url))==null){

                         result=ERROR_RETURN_CODE;

                         // For testing purposes only
                         // To avoid using IDMS/CMS
                         registerNow();
                         if(url!=null){
                             if(BuildConfig.DEBUG)Log.e(TAG,Constants.ConstantsErrorMCOP.LoginEventError.CCVI.getString());
                             sendErrorLoginEvent(Constants.ConstantsErrorMCOP.LoginEventError.CCVI);
                         }
                     }else{

                         if(BuildConfig.DEBUG && uri!=null && !url.trim().isEmpty())Log.d(TAG,"Authentication Token uri: "+url);
                         myCMSService.getAuthenticationToken(uri);

                         result=SUCCESS_RETURN_CODE;

                     }
                 }catch (Exception e){
                     if(BuildConfig.DEBUG)Log.e(TAG,Constants.ConstantsErrorMCOP.LoginEventError.CCVI.getString());
                     sendErrorLoginEvent(Constants.ConstantsErrorMCOP.LoginEventError.CCVI);
                 }

                 return result;
             }
 
             @Override

             public int makeCall(String[] userID, int callType, String sessionID, Map tags) throws RemoteException {

                 showInfoPackageName();

                 return makeCallMCOP((userID!=null && userID.length>0)?(userID[0]):null,callType,context)?SUCCESS_RETURN_CODE:ERROR_RETURN_CODE;

             }
 
             @Override

             public int hangUpCall(String sessionID) throws RemoteException {

                 showInfoPackageName();

                 return hangUpCallMCOP( sessionID)?SUCCESS_RETURN_CODE:ERROR_RETURN_CODE;

             }
 
             @Override

             public int acceptCall(String sessionID, Map tags) throws RemoteException {

                 showInfoPackageName();

                 return acceptCallMCOP(sessionID)?SUCCESS_RETURN_CODE:ERROR_RETURN_CODE;

             }
 
             @Override

             public int updateCallStatus(String sessionID, int callType) throws RemoteException {

                 showInfoPackageName();

                 //TODO: Currently not implemented
                 return ERROR_RETURN_CODE;

             }
 
             @Override

             public int controlMechanismOperation (String sessionID, int requestType, Map tags) throws RemoteException {

                 showInfoPackageName();

                 return floorControlOperationMCOP(sessionID,requestType,null)?SUCCESS_RETURN_CODE:ERROR_RETURN_CODE;

             }
 
             @Override

             public int getGroupsInfo() throws RemoteException {

                 showInfoPackageName();

                 //TODO: Currently not implemented
                 return ERROR_RETURN_CODE;

             }
 
             @Override

             public int getGroupsAffiliation() throws RemoteException {

                 showInfoPackageName();

                 if(BuildConfig.DEBUG)Log.d(TAG,"Execute updateGroupsAffiliation");

                 return newPresence()?SUCCESS_RETURN_CODE:ERROR_RETURN_CODE;

             }
 
             @Override

             public int affiliationOperation(String groupMcpttId, int affiliationOperation, Map tags) throws RemoteException {

                 showInfoPackageName();

                 return newOperationAffiliation(groupMcpttId,ConstantsMCOP.GroupAffiliationEventExtras.AffiliationRequestTypeEnum.fromInt(affiliationOperation))?SUCCESS_RETURN_CODE:ERROR_RETURN_CODE;

             }
 
             @Override

             public int selectInterface(String ip, Map tag) throws RemoteException {
                 //TODO: Currently not implemented
                 return ERROR_RETURN_CODE;
             }
 
             @Override
             public String generateUniqueId() throws RemoteException {
                 //TODO: Currently not implemented
                 return null;
             }
 
             @Override
             public int setMute(String sessionID, boolean mute) throws RemoteException {
                 //TODO: Currently not implemented
                 return ERROR_RETURN_CODE;
             }
 
             @Override
             public int setSpeakerMute(String sessionID, boolean mute) throws RemoteException {
                 //TODO: Currently not implemented
                 return ERROR_RETURN_CODE;
             }
 
             @Override
             public int changeRemoteGroup(String userID, String groupID, Map tags) throws RemoteException {
                 //TODO: Currently not implemented
                 return ERROR_RETURN_CODE;
             }
 
             @Override
             public int setGroupEmergencyAlertState(String groupID, boolean enable, Map tags) throws RemoteException {
                 //TODO: Currently not implemented
                 return ERROR_RETURN_CODE;
             }
 
             @Override
             public int getConfigurationInfo() throws RemoteException {
                 //TODO: Currently not implemented
                 return ERROR_RETURN_CODE;
             }
 
             @Override
             public int getFunctionalAliasStatus() throws RemoteException {
                 //TODO: Currently not implemented
                 return ERROR_RETURN_CODE;
             }
 
             @Override
             public int functionalAliasOperation(String functionalAliasId, int functionalAliasRequestType, Map tags) throws RemoteException {
                 //TODO: Currently not implemented
                 return ERROR_RETURN_CODE;
             }
 
             @Override
             public String createConversation(String recipientID, int conversationType, int defaultDispositionReqType) throws RemoteException {
                 //TODO: Currently not implemented
                 return null;
             }
 
             @Override
             public String sendSDS(String conversationID, String[] payloads, int[] payloadsType, long dateTime, String inReplyToID, int notificationType) throws RemoteException {
                 //TODO: Currently not implemented
                 return null;
             }
 
             @Override
             public int readNotificationSDS(String recipientID, String conversationID, String messageID) throws RemoteException {
                 //TODO: Currently not implemented
                 return ERROR_RETURN_CODE;
             }
 
             @Override
             public int getAllSDS(String conversationID, String recipientID, Map tags) throws RemoteException {
                 //TODO: Currently not implemented
                 return ERROR_RETURN_CODE;
             }
 
             @Override
             public int groupManagementOperation(String groupID, int groupOperationType, Map tags) throws RemoteException {
                 //TODO: Currently not implemented
                 return ERROR_RETURN_CODE;
             }
 
             @Override
             public int affiliationSubscriptionOperation(String userID, boolean enable) throws RemoteException {
                 //TODO: Currently not implemented
                 return ERROR_RETURN_CODE;

             }
 
             @Override
             public boolean registerCallback(IMCOPCallback mcopCallBack) throws RemoteException {

                 showInfoPackageName();

                 boolean result=false;
                 if(mcopCallBack!=null){
                     mMCOPCallback=mcopCallBack;
                     result=true;
                 }else{
                     Log.e(TAG,"CallBack Error");
                 }

                 if(BuildConfig.DEBUG)Log.d(TAG,"Execute registerCallback "+result);

                 return result;
             }

         };
 

 
         return iBinder;
     }
 
     private void affiliationImplicitGroups(){

         //Affiliating to group from CMS
         NgnSipPrefrences profile= NgnEngine.getInstance().getProfilesService().getProfileNow(context);
         if(profile!=null &&
                 profile.isMcpttEnableCMS()!=null &&
                 profile.isMcpttEnableCMS() &&
                 profile.getMCPTTGroupInfo()!=null){
             List<String> stringsAffiliationGroup=org.doubango.utils.Utils.parseAccountToEntry(profile.getImplicitCheckedAffiliations());
             if(stringsAffiliationGroup!=null && !stringsAffiliationGroup.isEmpty()){
                 Log.w(TAG,"Available groups for affiliation. Size: "+stringsAffiliationGroup.size());

                 newOperationAffiliation(stringsAffiliationGroup, ConstantsMCOP.GroupAffiliationEventExtras.AffiliationRequestTypeEnum.AffiliationRequestSelfAffiliate);

             }else{
                 Log.w(TAG,"No groups available for affiliation.");
             }
         }

     }
 

     public boolean stopManagerClient(){
         if(BuildConfig.DEBUG)Log.d(TAG, "stopManagerClient");

         System.exit(0);

         engineIapi.stop();
         if(managerSessions!=null)
         managerSessions.stopManagerSessions();
         if (mSipBroadcastRecvRegister != null) {
             if(BuildConfig.DEBUG)Log.d(TAG, "unregisterReceiver: Register");
             context.unregisterReceiver(mSipBroadcastRecvRegister);
             mSipBroadcastRecvRegister=null;
         }

 
         if(ngnSipService!=null && ngnSipService.isRegistered()){
 
             ngnSipService.unRegister();
             if(ngnEngine.isStarted()){
                 ngnEngine.stop();
             }
         }
 

         return true;
     }
 

     public boolean onDestroyClient(){
         if(BuildConfig.DEBUG)Log.d(TAG, "onDestroyClient");
         if (mSipBroadcastRecvRegister != null) {
             if(BuildConfig.DEBUG)Log.d(TAG, "unregisterReceiver: Register");
             context.unregisterReceiver(mSipBroadcastRecvRegister);
             mSipBroadcastRecvRegister=null;
         }
         if(managerSessions!=null)
             managerSessions.stopManagerSessions();
         ngnEngine.stop();
         engineIapi.isStarted();
         engineIapi.stop();
         return false;
     }
 
 
 
     //Only for testing purposes
     public boolean selectProfileMCOP2(String data){
         if(ngnEngine.getProfilesService()==null || ngnEngine.getProfilesService().getProfilesNames(context)==null){

             if(BuildConfig.DEBUG) Log.e(TAG,"Error in load profiles from MCOP SDK");

             return false;
         }
         for(String names:ngnEngine.getProfilesService().getProfilesNames(context)){

             if(BuildConfig.DEBUG) Log.d(TAG,"User Profile \""+names+"\"");

         }
 
         boolean result=ngnEngine.getProfilesService().setProfileNow(context,data);

         if(BuildConfig.DEBUG)Log.d(TAG,"Configure Profile \""+data+"\""+" result: "+result);
         return result;
     }
 
     //Only for testing purposes
     public boolean importProfileMCOP2(String profile){
         boolean result=false;
         if(ngnEngine!=null)
             result=ngnEngine.getProfilesService().importProfiles(profile,context);

         return result;
     }
 
 
     //START AUTHENTICATION EVENT
     private boolean sendAuthorizationRequestDataEvent(String requestUri, String redirectUri){

         Intent event = new Intent(ConstantsMCOP.ActionsCallBack.registrationEvent.toString());
         event.putExtra(ConstantsMCOP.RegistrationEventExtras.EVENT_TYPE, ConstantsMCOP.RegistrationEventExtras.RegistrationEventTypeEnum.RegisterEventIdmsAuth.getValue());
         event.putExtra(ConstantsMCOP.RegistrationEventExtras.REQUEST_URI, requestUri);
         event.putExtra(ConstantsMCOP.RegistrationEventExtras.REDIRECT_URI, redirectUri);

         return sendEvent(event);
     }
 
     private boolean sendErrorAuthorizationEvent(Constants.ConstantsErrorMCOP.AuthorizationRequestEventError authorizationRequestEventError){

         if(authorizationRequestEventError==null || mMCOPCallback==null){

             if (org.mcopenplatform.muoapi.BuildConfig.DEBUG) {
                 Log.e(TAG, "mMCOPCallback or AuthorizationEvent is null");
             }

             return false;
         }

         Intent event = new Intent(ConstantsMCOP.ActionsCallBack.registrationEvent.toString());
         event.putExtra(ConstantsMCOP.RegistrationEventExtras.EVENT_TYPE, ConstantsMCOP.RegistrationEventExtras.RegistrationEventTypeEnum.RegisterEventError.getValue());

         Log.e(TAG, "LoginEvent Error "+ authorizationRequestEventError.getCode()+": "+ authorizationRequestEventError.getString());
 
         //Error Code

         event.putExtra(ConstantsMCOP.RegistrationEventExtras.ERROR_CODE, authorizationRequestEventError.getCode());

         //Error String

         event.putExtra(ConstantsMCOP.RegistrationEventExtras.ERROR_STRING, authorizationRequestEventError.getString());

         return sendEvent(event);
     }
     //END AUTHENTICATION EVENT
 
     //START LOGIN EVENT
     private boolean sendLoginEvent(boolean isRegisted){

         Intent event = new Intent(ConstantsMCOP.ActionsCallBack.registrationEvent.toString());
         event.putExtra(ConstantsMCOP.RegistrationEventExtras.EVENT_TYPE, ConstantsMCOP.RegistrationEventExtras.RegistrationEventTypeEnum.RegisterEventSuccess.getValue());

         if(isRegisted && ngnEngine.getProfilesService().getProfileNow(context)!=null){
             String mcpttID=ngnEngine.getProfilesService().getProfileNow(context).getMcpttId();

             event.putExtra(ConstantsMCOP.RegistrationEventExtras.MCPTT_ID,mcpttID);

             String displayName=mcpttID;

             displayName=ngnEngine.getProfilesService().getProfileNow(context).getDisplayName();

             event.putExtra(ConstantsMCOP.RegistrationEventExtras.DISPLAY_NAME,displayName);

         }
         return sendEvent(event);
     }
 
     private boolean sendErrorLoginEvent(Constants.ConstantsErrorMCOP.LoginEventError loginEventError){

         if(loginEventError==null || mMCOPCallback==null){

             if (org.mcopenplatform.muoapi.BuildConfig.DEBUG) {
                 Log.e(TAG, "mMCOPCallback or LoginEvent is null");
             }

             return false;

         }
         ;
         Intent event = new Intent(ConstantsMCOP.ActionsCallBack.registrationEvent.toString());
         event.putExtra(ConstantsMCOP.RegistrationEventExtras.EVENT_TYPE, ConstantsMCOP.RegistrationEventExtras.RegistrationEventTypeEnum.RegisterEventError.getValue());

         Log.e(TAG, "LoginEvent Error "+ loginEventError.getCode()+": "+ loginEventError.getString());
 
         //Error Code

         event.putExtra(ConstantsMCOP.RegistrationEventExtras.ERROR_CODE, loginEventError.getCode());

         //Error String

         event.putExtra(ConstantsMCOP.RegistrationEventExtras.ERROR_STRING, loginEventError.getString());

         return sendEvent(event);
     }
     //END LOGIN EVENT
 
     //START LOGOUT EVENT
     private boolean sendUnLoginEvent(boolean isUnRegisted){

         Intent event=new Intent(ConstantsMCOP.ActionsCallBack.registrationEvent.toString());
         if(isUnRegisted){
             event.putExtra(ConstantsMCOP.RegistrationEventExtras.EVENT_TYPE, ConstantsMCOP.RegistrationEventExtras.RegistrationEventTypeEnum.UnregisterEventSuccess.getValue());
         }else {
             event.putExtra(ConstantsMCOP.RegistrationEventExtras.EVENT_TYPE, ConstantsMCOP.RegistrationEventExtras.RegistrationEventTypeEnum.UnregisterEventError.getValue());
         }

         return sendEvent(event);
     }
 
     private boolean sendErrorUnLoginEvent(Constants.ConstantsErrorMCOP.UnLoginEventError unLoginEventError){
         if(unLoginEventError==null || mMCOPCallback==null){

             if (org.mcopenplatform.muoapi.BuildConfig.DEBUG) {
                 Log.e(TAG, "mMCOPCallback or unLoginEventError is null");
             }

             return false;
         }

         Intent event = new Intent(ConstantsMCOP.ActionsCallBack.registrationEvent.toString());
         event.putExtra(ConstantsMCOP.RegistrationEventExtras.EVENT_TYPE, ConstantsMCOP.RegistrationEventExtras.RegistrationEventTypeEnum.UnregisterEventError.getValue());

         Log.e(TAG, "LoginEvent Error "+ unLoginEventError.getCode()+": "+ unLoginEventError.getString());
         //Error Code

         event.putExtra(ConstantsMCOP.RegistrationEventExtras.ERROR_CODE, unLoginEventError.getCode());

         //Error String

         event.putExtra(ConstantsMCOP.RegistrationEventExtras.ERROR_STRING, unLoginEventError.getString());

         return sendEvent(event);
     }
     //END LOGOUT EVENT
 
     //START CALL EVENT

     protected boolean makeCallMCOP(String userID, int type, Context context
 
                                    ){

         //TODO: Create priority logic for emergency calls
         if(!ngnEngine.isStarted() || !ngnSipService.isRegistered()){
             sendErrorCallEvent(Constants.ConstantsErrorMCOP.CallEventError.CDVII);
             return false;
         }

 
         boolean answerMode=false;
         Boolean aBoolean=ngnEngine.getAuthenticationService().isAllowAutomaticCommencement(context);
         answerMode=((aBoolean==null || !aBoolean)?false:true);
 
         int priority=-1;
         Constants.CallEvent.CallTypeValidEnum typeCall=null;
         if((typeCall= validationCallType(type))!=null &&

                 ((typeCall.getValue() & ConstantsMCOP.CallEventExtras.CallTypeEnum.CallSubtypeEmergency.getValue())== ConstantsMCOP.CallEventExtras.CallTypeEnum.CallSubtypeEmergency.getValue() ||
                 (typeCall.getValue() & ConstantsMCOP.CallEventExtras.CallTypeEnum.CallSubtypeImminentPeril.getValue())== ConstantsMCOP.CallEventExtras.CallTypeEnum.CallSubtypeImminentPeril.getValue())

             )//TODO: now the SDK doesn´t have priority default.
             priority=9;

         return  makeCallMCOPStart( userID,  type

                 , answerMode
                 ,priority

                 ,  context);
     }
 
     protected boolean makeCallMCOPStart(String userID, int type

             ,boolean answerMode
             , int priority

             , Context context){
         //TODO: Verify that the client has permission to perform the particular call type
         //With type select if valid call type

         boolean result=false;
         if(BuildConfig.DEBUG)Log.d(TAG,"makeCallMCOPStart");

         Constants.CallEvent.CallTypeValidEnum typeCall=null;
         if(userID==null || userID.trim().isEmpty() || !NgnUriUtils.isValidSipUri(userID)){
             sendErrorCallEvent(Constants.ConstantsErrorMCOP.CallEventError.CDIIII);
         }else if(type<=0 || (typeCall= validationCallType(type))==null){
             sendErrorCallEvent(Constants.ConstantsErrorMCOP.CallEventError.CDI);
         }else{
             NgnAVSession session=null;
             long newID=-1;
             NgnMediaType typeCallNgn=NgnMediaType.None;
             switch (typeCall) {
                 case AudioWithoutFloorCtrlPrivate:

                     typeCallNgn=NgnMediaType.SessionAudioMCPTT;

                     break;
                 case AudioWithFloorCtrlPrivate:

                     typeCallNgn=NgnMediaType.SessionAudioMCPTTWithFloorControl;

                     break;
                 case AudioWithFloorCtrlPrivateEmergency:

                     typeCallNgn=NgnMediaType.SessionEmergencyAudioMCPTTWithFloorControl;
                     if(BuildConfig.DEBUG)Log.d(TAG,"Type call:"+"AudioWithFloorCtrlPrivateEmergency  " + typeCallNgn.getValue());
 

                     break;
                 case AudioWithFloorCtrlPrearrangedGroupEmergency:

                     typeCallNgn=NgnMediaType.SessionEmergencyAudioGroupMCPTTWithFloorControl;
                     if(BuildConfig.DEBUG)Log.d(TAG,"Type call:"+"AudioWithFloorCtrlPrearrangedGroupEmergency  " + typeCallNgn.getValue());
 

                     break;
                 case AudioWithFloorCtrlPrearrangedGroupImminentPeril:

 
                     typeCallNgn=NgnMediaType.SessionImminentperilAudioGroupMCPTTWithFloorControl;
                     if(BuildConfig.DEBUG)Log.d(TAG,"Type call:"+"AudioWithFloorCtrlPrearrangedGroupImminentPeril  " + typeCallNgn.getValue());

                     break;
                 case AudioWithFloorCtrlPrearrangedGroup:

                     typeCallNgn=NgnMediaType.SessionAudioGroupMCPTTWithFloorControl;

                     if(BuildConfig.DEBUG)Log.d(TAG,"Type call:"+"AudioWithFloorCtrlPrearrangedGroup   " + typeCallNgn.getValue());
 
                     break;
                 case AudioWithFloorCtrlChatGroupEmergency:

                     typeCallNgn=NgnMediaType.SessionEmergencyAudioWithFloorCtrlChatGroup;
                     if(BuildConfig.DEBUG)Log.d(TAG,"Type call:"+"AudioWithFloorCtrlChatGroupEmergency   " + typeCallNgn.getValue());

                     break;
                 case AudioWithFloorCtrlChatGroupImminentPeril:
                     break;
                 case AudioWithFloorCtrlChatGroup:

                     typeCallNgn=NgnMediaType.SessionAudioChatGroupMCPTTWithFloorControl;
                     if(BuildConfig.DEBUG)Log.d(TAG,"Type call:"+"SessionAudioChatGroupMCPTTWithFloorControl   " + typeCallNgn.getValue());

                     break;
                 case AudioWithFloorCtrlBroadcastpEmergency:
                     break;
                 case AudioWithFloorCtrlBroadcastImminentPeril:
                     break;
                 case AudioWithFloorCtrlBroadcast:
                     break;
                 case AudioWithFloorCtrlFirstToAnswer:
                     break;
                 case AudioWithFloorCtrlPrivateCallCallback:
                     break;
                 case AudioWithFloorCtrlRemoteAmbientListening:
                     break;
                 case AudioWithFloorCtrlLocalAmbientListening:
                     break;
                 case VideoAudioWithFloorCtrlPrivate:
                     break;
                 case VideoAudioWithFloorCtrlPrivateEmergency:
                     break;
                 case VideoAudioWithFloorCtrlPrearrangedGroupEmergency:
                     break;
                 case VideoAudioWithFloorCtrlPrearrangedGroupImminentPeril:
                     break;
                 case VideoAudioWithFloorCtrlPrearrangedGroup:
                     break;
                 case VideoAudioWithFloorCtrlChatGroupEmergency:
                     break;
                 case VideoAudioWithFloorCtrlChatGroupImminentPeril:
                     break;
                 case VideoAudioWithFloorCtrlChatGroup:
                     break;
                 case VideoAudioWithFloorCtrlBroadcastpEmergency:
                     break;
                 case VideoAudioWithFloorCtrlBroadcastImminentPeril:
                     break;
                 case VideoAudioWithFloorCtrlBroadcast:
                     break;
                 case VideoAudioWithFloorCtrlFirstToAnswer:
                     break;
                 case VideoAudioWithFloorCtrlPrivateCallCallback:
                     break;
                 case VideoAudioWithFloorCtrlRemoteAmbientListening:
                     break;
                 case VideoAudioWithFloorCtrlLocalAmbientListening:
                     break;
                 default:
                     Log.e(TAG,"The call type is not properly known");
                     break;
             }
             if(typeCallNgn==null || typeCallNgn==NgnMediaType.None){
                 Log.e(TAG,"Session create error");
                 sendErrorCallEvent(Constants.ConstantsErrorMCOP.CallEventError.CDI);
             }else{
                 session = NgnAVSession.createOutgoingSession(
                         NgnEngine.getInstance().getSipService().getSipStack(),
                         typeCallNgn
                 );
                 newID=managerSessions.newSession(session);

                 if(BuildConfig.DEBUG)Log.d(TAG,"Create new session ID: "+newID);
 

                 if(newID<=0){
                     Log.e(TAG,"Session create error");
                     sendErrorCallEvent(Constants.ConstantsErrorMCOP.CallEventError.CDVI);
                 }else{
                     Log.d(TAG,"Init session");

                     result=session.makeCallMCPTT(

                             NgnUriUtils.makeValidSipUri(userID,context)
                             ,context

                             , answerMode
                             ,NgnAVSession.EmergencyCallType.MCPTT_P
                             ,priority

                     );
                 }
             }
 
         }

         return result;

     }
 
     private boolean hangUpCallMCOP(String sessionID){
         if(managerSessions==null){
             return false;
         }
         return managerSessions.hangUpCall(sessionID);
     }
 
     private boolean acceptCallMCOP(String sessionID){
         if(managerSessions==null){
             return false;
         }
         return managerSessions.acceptCall(sessionID);
     }
 
     public boolean floorControlOperationMCOP(String sessionID, int requestType, String userID){
         try{

             ConstantsMCOP.ControlMechanismEventExtras.ControlMechanismOperationTypeEnum ControlMechanismOperationTypeEnum=ConstantsMCOP.ControlMechanismEventExtras.ControlMechanismOperationTypeEnum.fromInt(requestType);

             if(managerSessions==null){
                 return false;
             }

             return managerSessions.floorControlOperation(sessionID,ControlMechanismOperationTypeEnum,userID);

         }catch (Exception ex){
 
         }
         return false;
     }
 
     private boolean sendErrorCallEvent(Constants.ConstantsErrorMCOP.CallEventError callEventError){
         return sendErrorCallEvent(callEventError,null);
     }
 
     private boolean sendErrorCallEvent(Constants.ConstantsErrorMCOP.CallEventError callEventError,String sessionID){

         if(callEventError==null || mMCOPCallback==null){
             if(BuildConfig.DEBUG) Log.e(TAG,"mMCOPCallback or CallEvent is null");
             return false;
         }

         Intent event=new Intent(ConstantsMCOP.ActionsCallBack.callEvent.toString());
         Log.e(TAG, "CallEvent Error "+ callEventError.getCode()+": "+ callEventError.getString());
         if(sessionID!=null && !sessionID.trim().isEmpty())
         event.putExtra(ConstantsMCOP.CallEventExtras.SESSION_ID,sessionID);
         //put eventType ERROR

         event.putExtra(ConstantsMCOP.CallEventExtras.EVENT_TYPE, ConstantsMCOP.CallEventExtras.CallEventTypeEnum.CallEventError.getValue());

         //put Code Error
         event.putExtra(ConstantsMCOP.CallEventExtras.ERROR_CODE,callEventError.getCode());
         //put String Error
         event.putExtra(ConstantsMCOP.CallEventExtras.ERROR_STRING,callEventError.getString());
         return sendEvent(event);
     }
 

     @Override
     public void onEvents(List<Intent> events) {
         sendEvents(events);
     }
 
     private synchronized boolean sendEvents(final List<Intent> events){

         if(events==null || events.isEmpty() ){
             if(BuildConfig.DEBUG) Log.e(TAG,"Event is null");
             return false;
         }else if(mMCOPCallback==null){
             if(BuildConfig.DEBUG) Log.e(TAG,"mMCOPCallback is null");
 
         }
 

         new Handler(Looper.getMainLooper()).post(new Runnable() {
             public void run() {
                 try {

                     if(BuildConfig.DEBUG)Log.i(TAG,"Send event");

                     mMCOPCallback.handleOnEvent(events);
                 } catch (RemoteException e) {
                     Log.e(TAG,"Error sending event to client: "+e.getMessage());
                 } catch (Exception e) {
                     Log.e(TAG,"Error sending events: "+e.getMessage());
                 }
             }
         });
         return true;
     }
 
     private boolean sendEvent(final Intent event){

         if(event==null ){
             if(BuildConfig.DEBUG)Log.e(TAG,"the event could not be sent");
             return false;
         }

         List<Intent> events=new ArrayList<>();
         events.add(event);
         return sendEvents(events);
     }
 
 
     private void registerNow(){
         Log.d(TAG,"Starting Registration Process");

         if(ngnSipService==null || ngnSipService.isRegistered() || !ngnSipService.register(false,context)){

             sendErrorLoginEvent(Constants.ConstantsErrorMCOP.LoginEventError.CCVII);

             if(BuildConfig.DEBUG)Log.e(TAG,"No Start register correct");
         }else{
             if(BuildConfig.DEBUG)Log.i(TAG,"Start register correct");
         }
     }
 
 
     //START Authentication Event
     @Override
     public void onAuthentication(String dataURI, String redirectionURI) {
         if(BuildConfig.DEBUG)Log.d(TAG,"onAuthentication dataURI:"+dataURI+" redirectionURI:"+redirectionURI);
         if(dataURI!=null && redirectionURI!=null){
             sendAuthorizationRequestDataEvent(dataURI,redirectionURI);
         }else{
             sendErrorAuthorizationEvent(Constants.ConstantsErrorMCOP.AuthorizationRequestEventError.CI);

         }
     }
 

     @Override
     public void onAuthenticationOk(String data) {
         //If you use CMS and IDMS or IDMS only, it is necessary to register after being authenticated
         registerNow();
         //TODO: Define send info onAuthenticationOk
     }

     @Override
     public void onAuthenticationError(String error) {
         //TODO: Define send info onAuthenticationError
         sendErrorLoginEvent(Constants.ConstantsErrorMCOP.LoginEventError.CCVIII);
     }
 
     @Override
     public void onAuthenticationRefresh(String refresh) {
         //TODO: Define send info onAuthenticationRefresh
         if(BuildConfig.DEBUG)Log.d(TAG,"onAuthenticationRefresh");
     }
 
     @Override
     public void onGetmcpttUEInitialConfiguration(org.doubango.ngn.datatype.ms.cms.mcpttUEInitConfig.McpttUEInitialConfiguration mcpttUEInitialConfiguration) {
         //TODO: Define send info onGetmcpttUEInitialConfiguration
         if(BuildConfig.DEBUG)Log.d(TAG,"onGetmcpttUEInitialConfiguration");
     }
 
     @Override
     public void onGetmcpttUEInitialConfigurationError(String error) {
         //TODO: Define send info onGetmcpttUEInitialConfigurationError
         sendErrorLoginEvent(Constants.ConstantsErrorMCOP.LoginEventError.CV);
     }
 
     @Override
     public void onGetMcpttUEConfiguration(org.doubango.ngn.datatype.ms.cms.mcpttUEConfig.McpttUEConfiguration mcpttUEConfiguration) {
         //TODO: Define send info onGetMcpttUEConfiguration
         if(BuildConfig.DEBUG)Log.d(TAG,"onGetMcpttUEConfiguration");
     }
 
     @Override
     public void onGetMcpttUEConfigurationError(String error) {
         //TODO: Define send info onGetMcpttUEConfigurationError
         sendErrorLoginEvent(Constants.ConstantsErrorMCOP.LoginEventError.CV);
     }
 
     @Override
     public void onGetMcpttServiceConf(org.doubango.ngn.datatype.ms.cms.mcpttServiceConfig.ServiceConfigurationInfoType mcpttServiceConf) {
         //TODO: the Process CMS is FINISH
         if(BuildConfig.DEBUG)Log.d(TAG,"onGetMcpttServiceConf");
     }
 
     @Override
     public void onStable() {
         registerNow();
     }
 
     @Override
     public void onGetMcpttServiceConfError(String error) {
         sendErrorLoginEvent(Constants.ConstantsErrorMCOP.LoginEventError.CVII);
     }
 
     @Override
     public void onGetMcpttUserDefaultProfile(McpttUserProfile mcpttUserProfile) {
         //TODO: Process CMS UserProfile default
         if(BuildConfig.DEBUG)Log.d(TAG,"onGetMcpttUserDefaultProfile");
 
     }
 
     @Override
     public void onGetMcpttUserProfile(org.doubango.ngn.datatype.ms.cms.mcpttUserProfile.McpttUserProfile mcpttUserProfile) {
         //TODO: Process CMS UserProfile
         if(BuildConfig.DEBUG)Log.d(TAG,"onGetMcpttUserProfile");
     }
 
     @Override
     public void onGetMcpttUserProfileError(String error) {
         if(BuildConfig.DEBUG)Log.d(TAG,"onGetMcpttUserProfileError");
 
     }
 
     @Override
     public void onSelectMcpttUserProfile(List<String> mcpttUserProfiles) {
         if(BuildConfig.DEBUG)Log.d(TAG,"onSelectMcpttUserProfile");
 
     }
     //END Authentication Event

 
     //START Affiliation Event
     @Override
     public void receiveNewPresence(Presence presence) {
         newPresence(presence);
     }
 
     @Override
     public void receiveNewPresenceResponse(Presence presence, String pid) {
         newPresence(presence);
     }
 
     private boolean newPresence(){
         Presence presence=myAffiliationService.getPresenceNow();
         return newPresence(presence);
     }
 
     private boolean newPresence(Presence presence){
         Log.d(TAG,"New affiliation data received");
         if(presence==null ){
             Log.e(TAG,"Erroneous affiliation data received.");
             return false;
         }
 
         List<GroupAffiliation> groupAffiliations= Utils.checkPresence(presence,context);
         if(BuildConfig.DEBUG && groupAffiliations!=null)Log.d(TAG,"The groups received in Affiliation:"+groupAffiliations.size());
         return sendGroupAffiliationEvent(groupAffiliations);
     }
 
     @Override
     public void expireAffiliations(Map<String, String> expires) {
         Presence presence=ngnEngine.getAffiliationService().getPresenceNow();
         String mcpttClientID=null;
         NgnSipPrefrences profile= NgnEngine.getInstance().getProfilesService().getProfileNow(context);
         if(profile!=null)mcpttClientID=profile.getMcpttClientId();
         if(presence.getTuple()!=null && mcpttClientID!=null){
             for(Tuple tuple:presence.getTuple()){
                 if(tuple!=null && presence.getTuple().get(0).getStatus()!=null && tuple.getStatus().getAffiliations()!=null && tuple.getId().trim().equals(mcpttClientID)){
                     for(AffiliationType affiliation:presence.getTuple().get(0).getStatus().getAffiliations()){
                         if(expires.get(affiliation.getGroup())!=null){
                             affiliation.setStatus(StatusType.deaffiliating);
                         }
                     }
                 }
             }
         }
         newPresence(presence);
     }
 
     @Override
     public void receiveNewSelfAffiliation(CommandList commandList) {
         //TODO: Failed to develop the situation where another user asks for affiliation
     }
 
     @Override
     public void startNewServiceAffiliation() {
         //TODO: Possibly no longer needed, but it should be checked
     }
 

     private boolean newOperationAffiliation(List<String> groupIDs, ConstantsMCOP.GroupAffiliationEventExtras.AffiliationRequestTypeEnum operationTypeEnum){

         boolean result=false;
         ngnEngine.getProfilesService().getProfileNow(context);
         ArrayList<String> groupsAffiliation=new ArrayList<>();
         ArrayList<String> groupsUnAffiliation=new ArrayList<>();
         if(groupIDs!=null)
         for(String groupID:groupIDs){
             if(groupID!=null && !groupID.trim().isEmpty() && operationTypeEnum!=null){
                 Presence presence=null;
                 switch (operationTypeEnum) {

                     case AffiliationRequestSelfAffiliate:

                         //Verify that the group you want to AFFILIATE to is obtained from the CMS
                         presence=myAffiliationService.getPresenceNow();

                         if(presence==null
                                 ){

                             sendErrorGroupAffiliationEvent(Constants.ConstantsErrorMCOP.GroupAffiliationEventError.CVIII,groupID);
                             result=false;
                         }else if(!checkGroupIsExist(ngnEngine.getProfilesService().getProfileNow(context),groupID,context)
                                 ){
                             sendErrorGroupAffiliationEvent(Constants.ConstantsErrorMCOP.GroupAffiliationEventError.CVII,groupID);
                             result=false;
 
                         }else if(isAffiliatedGroup(presence,groupID,context)){
                             sendErrorGroupAffiliationEvent(Constants.ConstantsErrorMCOP.GroupAffiliationEventError.CV,groupID);
                             result=false;
                         }else if(isDeaffiliatedGroup(presence,groupID,context) || (!isDeaffiliatingGroup(presence,groupID,context) && !isAffiliatingGroup(presence,groupID,context))){
                             //The group exists
                             myAffiliationService.affiliationGroup(context,groupID);
                             groupsAffiliation.add(groupID);
                             result=true;
                         }else{
                             sendErrorGroupAffiliationEvent(Constants.ConstantsErrorMCOP.GroupAffiliationEventError.CIX,groupID);
                         }
                         break;

                     case AffiliationRequestSelfDeaffiliate:

                         //Verify that the group to DEAFFILIATE from was obtained from the CMS
                         presence=myAffiliationService.getPresenceNow();

                         if(presence==null
                                 ){

                             sendErrorGroupAffiliationEvent(Constants.ConstantsErrorMCOP.GroupAffiliationEventError.CVIII,groupID);
                             result=false;
                         }else if(!checkGroupIsExist(ngnEngine.getProfilesService().getProfileNow(context),groupID,context)
                                 ){
                             sendErrorGroupAffiliationEvent(Constants.ConstantsErrorMCOP.GroupAffiliationEventError.CVII,groupID);
                             result=false;
 
                         }else if(isDeaffiliatedGroup(presence,groupID,context)){
                             sendErrorGroupAffiliationEvent(Constants.ConstantsErrorMCOP.GroupAffiliationEventError.CVI,groupID);
                             result=false;
                         }else if(isAffiliatedGroup(presence,groupID,context) || (!isDeaffiliatingGroup(presence,groupID,context) && !isAffiliatingGroup(presence,groupID,context))){
                             //The group exists
                             groupsUnAffiliation.add(groupID);
                             result=true;
                         }else {
                             sendErrorGroupAffiliationEvent(Constants.ConstantsErrorMCOP.GroupAffiliationEventError.CIX,groupID);
                         }
                         break;
                 }
             }else{
                 sendErrorGroupAffiliationEvent(Constants.ConstantsErrorMCOP.GroupAffiliationEventError.CII,groupID);
                 result=false;
             }
         }
         if(groupsAffiliation!=null && !groupsAffiliation.isEmpty())
             myAffiliationService.affiliationGroups(context,groupsAffiliation);
         if(groupsUnAffiliation!=null && !groupsUnAffiliation.isEmpty())
             myAffiliationService.unAffiliationGroups(context,groupsUnAffiliation);
 
         return result;
     }
 

     private boolean newOperationAffiliation(String groupID, ConstantsMCOP.GroupAffiliationEventExtras.AffiliationRequestTypeEnum operationTypeEnum){

         List<String> groupIDs=new ArrayList<>();
         if(groupID!=null);
         groupIDs.add(groupID);
         return newOperationAffiliation(groupIDs,operationTypeEnum);
     }

     private boolean processNewGroup(org.doubango.ngn.datatype.ms.gms.ns.list_service.Group group){

         NgnSipPrefrences profile= NgnEngine.getInstance().getProfilesService().getProfileNow(context);

         if(group==null || profile==null || profile.getMcpttId()==null || profile.getMcpttId().isEmpty()){

             sendErrorGroupInfoEvent(Constants.ConstantsErrorMCOP.GroupInfoEventError.CI);
             return false;
         }

         ArrayList<GroupInfo> groupsInfo=new ArrayList<>();

         if(group.getListService()!=null)
         for(ListServiceType serviceType:group.getListService()){
             if(serviceType.getUri()!=null && !serviceType.getUri().trim().isEmpty()){
 
                 Set<ConstantsMCOP.GroupInfoEventExtras.AllowTypeEnum> allowTypes= ManagerClientUtils.getAllowsGroups(profile.getMcpttId(),serviceType);

                 Set<ConstantsMCOP.GroupInfoEventExtras.ActionRealTimeVideoType> actionRealTimeVideoTypes = ManagerClientUtils.getActionRealTimeVideoTypes(profile.getMcpttId(),serviceType);
                 Iterator<ConstantsMCOP.GroupInfoEventExtras.ActionRealTimeVideoType> actioinRealTimeVideoTypeIterator= actionRealTimeVideoTypes.iterator();

                 ConstantsMCOP.GroupInfoEventExtras.ActionRealTimeVideoType actionRealTimeVideo=null;

                 while(actioinRealTimeVideoTypeIterator.hasNext()){
                     ConstantsMCOP.GroupInfoEventExtras.ActionRealTimeVideoType allowType=actioinRealTimeVideoTypeIterator.next();
                     if(allowType== ConstantsMCOP.GroupInfoEventExtras.ActionRealTimeVideoType.nonRealTime){
                         actionRealTimeVideo= ConstantsMCOP.GroupInfoEventExtras.ActionRealTimeVideoType.nonRealTime;
                     }else if(allowType== ConstantsMCOP.GroupInfoEventExtras.ActionRealTimeVideoType.nonUrgentRealTime){
                         actionRealTimeVideo= ConstantsMCOP.GroupInfoEventExtras.ActionRealTimeVideoType.nonUrgentRealTime;
                     }else if(allowType== ConstantsMCOP.GroupInfoEventExtras.ActionRealTimeVideoType.urgentRealTime){
                         actionRealTimeVideo= ConstantsMCOP.GroupInfoEventExtras.ActionRealTimeVideoType.urgentRealTime;

                     }
                 }
 
                 GroupInfo groupInfo=new GroupInfo(
                         serviceType.getUri(),
                         serviceType.getDisplayName().getValue(),
                         allowTypes,
                         actionRealTimeVideo,//TODO: Maybe not correct
                         serviceType.getMcdataonnetworkmaxdatasizeforSDS(),
                         serviceType.getMcdataonnetworkmaxdatasizeforFD(),
                         serviceType.getMcdataonnetworkmaxdatasizeautorecv(),

                         ManagerClientUtils.getParticipantGroupsWithTypes(serviceType,URI),
                         ManagerClientUtils.getParticipantGroupsWithTypes(serviceType,DISPLAY_NAME),
                         ManagerClientUtils.getParticipantGroupsWithTypes(serviceType,TYPE)

                 );

                 groupsInfo.add(groupInfo);

             }

         }

         sendGroupInfoEvent(groupsInfo);

         return true;
     }
     private boolean sendGroupAffiliationEvent(List<GroupAffiliation> groupAffiliations){
         if(BuildConfig.DEBUG)Log.d(TAG,"sendGroupAffiliationEvent");
         Intent event=new Intent(ConstantsMCOP.ActionsCallBack.groupAffiliationEvent.toString());
         HashMap<String, Integer> stringIntegerHashMap=(HashMap<String, Integer>)Utils.groupAffiliationToMap(groupAffiliations);
         if(BuildConfig.DEBUG)Log.d(TAG,"stringIntegerHashMap size: "+stringIntegerHashMap.size());

         event.putExtra(ConstantsMCOP.GroupAffiliationEventExtras.EVENT_TYPE, ConstantsMCOP.GroupAffiliationEventExtras.AffiliationEventTypeEnum.AffiliationUpdate.getValue());
         event.putExtra(ConstantsMCOP.GroupAffiliationEventExtras.GROUP_AFFILIATION_STATUS_MAP,stringIntegerHashMap);

         return sendEvent(event);
     }
 
     private boolean sendErrorGroupAffiliationEvent(Constants.ConstantsErrorMCOP.GroupAffiliationEventError  groupAffiliationEventError ,String groupID){

         if(groupAffiliationEventError==null || mMCOPCallback==null ){
             if(BuildConfig.DEBUG) Log.e(TAG,"mMCOPCallback or GroupAffiliationEvent is null");
             return false;
         }

         Intent event=new Intent(ConstantsMCOP.ActionsCallBack.groupAffiliationEvent.toString());
         Log.e(TAG, "GroupAffiliationEvent Error "+ groupAffiliationEventError.getCode()+": "+ groupAffiliationEventError.getString());
         //Error Group ID
         if(groupID!=null && !groupID.trim().isEmpty())
         event.putExtra(ConstantsMCOP.GroupAffiliationEventExtras.GROUP_ID,groupID);
         //Event Type

         event.putExtra(ConstantsMCOP.GroupAffiliationEventExtras.EVENT_TYPE,ConstantsMCOP.GroupAffiliationEventExtras.AffiliationEventTypeEnum.AffiliationError.getValue());

         //Error Code
         event.putExtra(ConstantsMCOP.GroupAffiliationEventExtras.ERROR_CODE, groupAffiliationEventError.getCode());
         //Error String
         event.putExtra(ConstantsMCOP.GroupAffiliationEventExtras.ERROR_STRING, groupAffiliationEventError.getString());
         return sendEvent(event);
     }
     //END Affiliation Event
 
     //START Group Info Event
     private boolean sendGroupInfoEvent(List<GroupInfo> groupsInfo){

         if(BuildConfig.DEBUG)Log.d(TAG,"sendGroupInfoEvent");

         boolean result=true;
         Intent event=new Intent(ConstantsMCOP.ActionsCallBack.groupInfoEvent.toString());
         for(GroupInfo groupInfo:groupsInfo)
             if(groupInfo!=null){
                 event.putExtra(ConstantsMCOP.GroupInfoEventExtras.GROUP_ID,
                         groupInfo.getGroupID());
                 event.putExtra(ConstantsMCOP.GroupInfoEventExtras.DISPLAY_NAME,
                         groupInfo.getDisplayName());
                 event.putExtra(ConstantsMCOP.GroupInfoEventExtras.ALLOWS_GROUP,
                         ConstantsMCOP.GroupInfoEventExtras.AllowTypeEnum.getValue(groupInfo.getAllowList()));
                 event.putExtra(ConstantsMCOP.GroupInfoEventExtras.MAX_DATA_SIZE_FOR_SDS,
                         groupInfo.getMaxDataSizeForSDS());
                 event.putExtra(ConstantsMCOP.GroupInfoEventExtras.MAX_DATA_SIZE_FOR_FD,
                         groupInfo.getMaxDataSizeForFD());
                 event.putExtra(ConstantsMCOP.GroupInfoEventExtras.MAX_DATA_SIZE_AUTO_RECV,
                         groupInfo.getMaxDataSizeAutoRecv());

                 if(groupInfo.getActionRealTimeVideo()!=null)

                 event.putExtra(ConstantsMCOP.GroupInfoEventExtras.ACTIVE_REAL_TIME_VIDEO_MODE,
                         groupInfo.getActionRealTimeVideo().toString());

                 if(groupInfo.getActionRealTimeVideo()!=null)
                     event.putExtra(ConstantsMCOP.GroupInfoEventExtras.ACTIVE_REAL_TIME_VIDEO_MODE,
                             groupInfo.getActionRealTimeVideo().toString());
                 if(groupInfo.getParticipantsList()!=null){
                     event.putExtra(ConstantsMCOP.GroupInfoEventExtras.PARTICIPANTS_LIST,
                             new ArrayList<String>(groupInfo.getParticipantsList()));
                 }
                 if(groupInfo.getParticipantsList()!=null){
                     event.putStringArrayListExtra(ConstantsMCOP.GroupInfoEventExtras.PARTICIPANTS_LIST_DISPLAY_NAME,
                             new ArrayList<String>(groupInfo.getParticipantsListDisplay()));
                 }
                 if(groupInfo.getParticipantsList()!=null){
                     event.putStringArrayListExtra(ConstantsMCOP.GroupInfoEventExtras.PARTICIPANTS_LIST_TYPE,
                             new ArrayList<String>(groupInfo.getParticipantsListType()));
                 }

                 result&=sendEvent(event);
 

             }
         return result;
     }
 
     private boolean sendErrorGroupInfoEvent(Constants.ConstantsErrorMCOP.GroupInfoEventError  groupInfoEventError){

         if(groupInfoEventError==null || mMCOPCallback==null ){
             if(BuildConfig.DEBUG) Log.e(TAG,"mMCOPCallback or GroupInfoEvent is null");
             return false;
         }

         Intent event=new Intent(ConstantsMCOP.ActionsCallBack.groupInfoEvent.toString());
         Log.e(TAG, "GroupInfoEvent Error "+ groupInfoEventError.getCode()+": "+ groupInfoEventError.getString());
 
         //Error Code
         event.putExtra(ConstantsMCOP.GroupInfoEventExtras.ERROR_CODE, groupInfoEventError.getCode());
         //Error String
         event.putExtra(ConstantsMCOP.GroupInfoEventExtras.ERROR_STRING, groupInfoEventError.getString());
         return sendEvent(event);
     }
     //END org.doubango.ngn.datatype.gms.pocListService.ns.list_service.Group Info Event
 
     //START SIM AUTH
     @Override
     public String onAuthRegister(String nonce) {
         try {
             //TODO: Should be decided as and where it decides to use a slot of SIM or an algorithm specific CHECK
             String response = engineIapi.getSimService().getAuthentication( nonce.trim());
             return response;
         } catch (RemoteException e) {
             Log.e(TAG,"SIM Authorization Error: "+e.getMessage());
         }
         return null;
     }

 
 
     private void configureGetParameterSIM(){
         if(engineIapi!=null)
             engineIapi.getSimService().setOnSimServiceListener(new ManagerSimService.OnSimServiceListener() {
                 @Override
                 public void onConfiguration(final String[] impu, String impi, String domain, String[] pcscf, int pcscfPort[], String imsi, String imei) {
                     if(org.mcopenplatform.muoapi.BuildConfig.DEBUG){
                         if(BuildConfig.DEBUG)Log.d(TAG,"Configuration client:");
                         if(pcscf!=null && pcscf.length>0){
                             if(BuildConfig.DEBUG)Log.d(TAG,"pcscf: "+pcscf[0]);
                         }else
                             if(BuildConfig.DEBUG)Log.w(TAG,"pcscf is null");
                         if(pcscfPort!=null && pcscfPort.length>0){
                             if(BuildConfig.DEBUG)Log.d(TAG,"pcscf port: "+pcscfPort[0]);
                         }else
                             if(BuildConfig.DEBUG)Log.w(TAG,"pcscf is null");
                         if(impu!=null && impu.length>0){
                             if(BuildConfig.DEBUG)Log.d(TAG,"impu: "+impu[0]);
                         }else
                             if(BuildConfig.DEBUG)Log.w(TAG,"impu is null");
                         if(impi!=null){
                             if(BuildConfig.DEBUG) Log.d(TAG,"impi: "+impi);
                         }else
                             if(BuildConfig.DEBUG)Log.w(TAG,"impi is null");
                         if(domain!=null){
                             if(BuildConfig.DEBUG)Log.d(TAG,"domain: "+domain);
                         }else
                             if(BuildConfig.DEBUG)Log.w(TAG,"domain is null");
                         if(imei!=null) {
                             if(BuildConfig.DEBUG)Log.d(TAG,"imei: "+imei);
                         }else
                             if(BuildConfig.DEBUG)Log.w(TAG,"imei is null");
                         if(imsi!=null) Log.d(TAG,"imsi: "+imsi);
                     }
                     if(client==null)
                     client=new Client();
                     ClientSIM clientSIM=new ClientSIM(impu,impi,domain,pcscf,pcscfPort,imsi,imei);
                     client.setClientSIM(clientSIM);
                     configureParametersSIM();
                 }
             });
     }
 
     private void configureParametersSIM(){
         ClientSIM clientSIM=null;
         if(client==null ||(clientSIM=client.getClientSIM())==null){
             Log.e(TAG,"it is not possible to configure the SIM parameters");
         }
         if(ngnEngine!=null && context!=null){
             NgnSipPrefrences ngnSipPrefrences=ngnEngine.getProfilesService().getProfileNow(context);
             if(BuildConfig.DEBUG)Log.d(TAG,"configureParametersSIM execute");
             //TODO: select the best impu and pcscf
             String impu=null;
             if(clientSIM.getImpu()!=null && clientSIM.getImpu().length!=0 && (impu=clientSIM.getImpu()[0])!=null){
                 ngnSipPrefrences.setIMPU(impu);
             }else{
                 if(BuildConfig.DEBUG)Log.w(TAG,"No configure IMPU");
             }
 
             if(clientSIM.getImpi()!=null && !clientSIM.getImpi().trim().isEmpty()){
                 ngnSipPrefrences.setIMPI(clientSIM.getImpi().trim());
             }else{
                 if(BuildConfig.DEBUG)Log.w(TAG,"No configure IMPI");
             }
 
             if(clientSIM.getDomain()!=null && !clientSIM.getDomain().trim().isEmpty()){
                 ngnSipPrefrences.setRealm(clientSIM.getDomain().trim());
             }else{
                 if(BuildConfig.DEBUG)Log.w(TAG,"No configure Domain");
             }
 
 
             if(clientSIM.getImsi()!=null && !clientSIM.getImsi().trim().isEmpty()){
                 ngnSipPrefrences.setImsi(clientSIM.getImsi().trim());
             }else{
                 if(BuildConfig.DEBUG)Log.w(TAG,"No configure IMSI");
             }
 
             if(clientSIM.getImei()!=null && !clientSIM.getImei().trim().isEmpty()){
                 ngnSipPrefrences.setImei(clientSIM.getImei().trim());
             }
             else{
                 if(BuildConfig.DEBUG)Log.w(TAG,"No configure IMEI");
             }
 
             String pcscf=null;
             if(clientSIM.getPcscf()!=null && clientSIM.getPcscf().length!=0 && (pcscf=clientSIM.getPcscf()[0])!=null){
                 ngnSipPrefrences.setPcscfHost(pcscf);
             }else{
                 if(BuildConfig.DEBUG)Log.w(TAG,"No configure PCSCR");
             }
 
             if(clientSIM.getPcscfPort()!=null && clientSIM.getPcscfPort().length!=0 && clientSIM.getPcscfPort()[0]>0){
                 ngnSipPrefrences.setPcscfPort(clientSIM.getPcscfPort()[0]);
             }else{
                 if(BuildConfig.DEBUG)Log.w(TAG,"No configure PCSCR port");
             }
         }
     }
 
 
     //INIT GMS
     @Override
     public void onGMSErrorGroup(String error) {
 
     }
 
     @Override
     public void onGMSGroup(org.doubango.ngn.datatype.ms.gms.ns.list_service.Group group) {
         processNewGroup(group);
     }
     //END GMS
 
 

     //END SIM AUTH

 
 
 
 
     //INIT MBMS event
     private void initMBMSEvent(){
         if(engineIapi!=null)
         engineIapi.getMBMSGroupCom().setOnManagerMBMSGroupComListener(new ManagerMBMSGroupCom.OnManagerMBMSGroupComListener() {
             @Override
             public void startMbmsMedia(String sessionID, String tmgi) {
                 if(BuildConfig.DEBUG)Log.d(TAG,"startMbmsMedia tmgi:"+tmgi+" sessionID:"+sessionID);

                 sendMbmsInfoEvent(sessionID,tmgi,null, ConstantsMCOP.EMBMSNotificationEventExtras.EMBMSNotificationEventTypeEnum.EMBMSEventInUse);

             }
 
             @Override
             public void stopMbmsMedia(String sessionID, String tmgi) {
                 if(BuildConfig.DEBUG)Log.d(TAG,"stopMbmsMedia tmgi:"+tmgi+" sessionID:"+sessionID);

                 sendMbmsInfoEvent(sessionID,tmgi,null, ConstantsMCOP.EMBMSNotificationEventExtras.EMBMSNotificationEventTypeEnum.EMBMSEventNotInUse);

             }
         });
 
     }
 

     private boolean sendMbmsInfoEvent(@Nullable String sessionID, @Nullable  String tmgi, @Nullable String[] areaList,@NonNull ConstantsMCOP.EMBMSNotificationEventExtras.EMBMSNotificationEventTypeEnum EMBMSNotificationEventTypeEnum){

         if(BuildConfig.DEBUG)Log.d(TAG,"sendMbmsInfoEvent");
         boolean result=true;
         Intent event=new Intent(ConstantsMCOP.ActionsCallBack.eMBMSNotificationEvent.toString());

         event.putExtra(ConstantsMCOP.EMBMSNotificationEventExtras.EVENT_TYPE,EMBMSNotificationEventTypeEnum.getValue());
         switch (EMBMSNotificationEventTypeEnum){
             case EMBMSEventNone:

 
                 break;

             case EMBMSEventOutCoverage:
             case EMBMSEventInCoverage:

                 if(BuildConfig.DEBUG)Log.d(TAG,"NoeMBMSCoverage or UndereMBMSCoverage");
 
                 //TODO
                 break;

             case EMBMSEventInUse:
             case EMBMSEventNotInUse:

                 if(BuildConfig.DEBUG)Log.d(TAG,"eMBMSBearerInUse or eMBMSBearerNotInUse");
                 if(sessionID!=null)
                 event.putExtra(ConstantsMCOP.EMBMSNotificationEventExtras.SESSION_ID,sessionID);
                 if(tmgi!=null)
                 event.putExtra(ConstantsMCOP.EMBMSNotificationEventExtras.TMGI,tmgi);
                 break;

             case EMBMSEventAvailable:
             case EMBMSEventNotAvailable:

                 if(BuildConfig.DEBUG)Log.d(TAG,"eMBMSAvailable or eMBMSNotAvailable");
 
                 //TODO
                 break;
             default:
                 if(BuildConfig.DEBUG)Log.d(TAG,"event mbms default");
                 break;
         }
                 result&=sendEvent(event);
 
         return result;
     }
 
     private boolean sendErrorMbmsInfoEvent(Constants.ConstantsErrorMCOP.MbmsInfoEventError  mbmsInfoEventError){
         if(mbmsInfoEventError==null || mMCOPCallback==null ){
             if(BuildConfig.DEBUG) Log.e(TAG,"mMCOPCallback or mbmsInfoEventError is null");
             return false;
         }
         Intent event=new Intent(ConstantsMCOP.ActionsCallBack.groupInfoEvent.toString());
         Log.e(TAG, "MbmsInfoEventError Error "+ mbmsInfoEventError.getCode()+": "+ mbmsInfoEventError.getString());
 
         //Error Code
         event.putExtra(ConstantsMCOP.EMBMSNotificationEventExtras.ERROR_CODE, mbmsInfoEventError.getCode());
         //Error String
         event.putExtra(ConstantsMCOP.EMBMSNotificationEventExtras.ERROR_STRING, mbmsInfoEventError.getString());
         return sendEvent(event);
     }
     //END MBMS event
 
 
 
     @Override
     public void onCMSPrivateContactsError() {
         sendConfigurationInfoError(Constants.ConstantsErrorMCOP.ConfigurationUpdateEventError.CI);
     }
 
     @Override
     public void onCMSPrivateContacts(McpttUserProfile mcpttUserProfile) {
         boolean success = false;
         if(mcpttUserProfile ==null || mMCOPCallback==null ){
             if(BuildConfig.DEBUG) Log.e(TAG,"mMCOPCallback or mcpttUserConfiguration info is null");
             //return false;
         }

         Intent event=new Intent(ConstantsMCOP.ActionsCallBack.configurationInfoEvent.toString());
         event.putExtra(ConstantsMCOP.ConfigurationInfoEventExtras.EVENT_TYPE,
                 ConstantsMCOP.ConfigurationInfoEventExtras.ConfigurationInfoEventTypeEnum.ConfigurationInfoMcpttUserConf.toString());

 
         if (mcpttUserProfile!=null && mcpttUserProfile.getCommon() != null && mcpttUserProfile.getCommon().size() > 0 && mcpttUserProfile.getCommon().get(0) != null) {
 
             org.doubango.ngn.datatype.ms.cms.mcpttUserProfile.CommonType commonType = mcpttUserProfile.getCommon().get(0);
             if (commonType.getMissionCriticalOrganization() != null && commonType.getMissionCriticalOrganization().size() > 0 && commonType.getMissionCriticalOrganization().get(0) != null) {

                 event.putExtra(ConstantsMCOP.ConfigurationInfoEventExtras.ORGANIZATION, commonType.getMissionCriticalOrganization().get(0));

             }
             //DEFAULT_EMERGENCY_CONTACT
             if (commonType.getPrivateCall() != null && commonType.getPrivateCall().size() > 0 && commonType.getPrivateCall().get(0) != null &&
                     commonType.getPrivateCall().get(0).getEmergencyCall() != null && commonType.getPrivateCall().get(0).getEmergencyCall().getMCPTTGroupInitiation() != null
                     && commonType.getPrivateCall().get(0).getEmergencyCall().getMCPTTGroupInitiation().getEntry() != null
                     && commonType.getPrivateCall().get(0).getEmergencyCall().getMCPTTGroupInitiation().getEntry().getUriEntry() != null) {

                 event.putExtra(ConstantsMCOP.ConfigurationInfoEventExtras.DEFAULT_EMERGENCY_CONTACT, commonType.getPrivateCall().get(0).getEmergencyCall().getMCPTTGroupInitiation().getEntry().getUriEntry());

             }
 
             //PRIVATE CONTACTS
             if (commonType.getPrivateCall() != null && commonType.getPrivateCall().size() > 0 && commonType.getPrivateCall().get(0) != null &&
                     commonType.getPrivateCall().get(0).getPrivateCallList() != null && commonType.getPrivateCall().get(0).getPrivateCallList().getPrivateCallURI() != null) {
                 List<String> privateContactsSIPUri = new ArrayList<>();
                 List<String> privateContactsDisplayName = new ArrayList<>();
                 for (org.doubango.ngn.datatype.ms.cms.mcpttUserProfile.EntryType entryType : commonType.getPrivateCall().get(0).getPrivateCallList().getPrivateCallURI()) {
                     if (entryType != null) {
                         if (entryType.getUriEntry() != null) {
                             privateContactsSIPUri.add(entryType.getUriEntry());
                         }
                         if (entryType.getDisplayName() != null && entryType.getDisplayName().getValue() != null) {
                             privateContactsDisplayName.add(entryType.getDisplayName().getValue());
                         }
                     }
                 }

                 event.putExtra(ConstantsMCOP.ConfigurationInfoEventExtras.PRIVATE_CONTACT_LIST,(Serializable) privateContactsSIPUri);
                 event.putExtra(ConstantsMCOP.ConfigurationInfoEventExtras.PRIVATE_CONTACT_DISPLAY_NAME_LIST, (Serializable) privateContactsDisplayName);

 
             }
         }
             //USER PERMISSIONS
             //They are considered granted in case of missing (defined in the constructor)

             List<ConstantsMCOP.ConfigurationInfoEventExtras.McpttAllowTypeEnum> allowTypeEnumList = new ArrayList<>();

             if (mcpttUserProfile.getRuleset() != null && mcpttUserProfile.getRuleset().getRule() != null
                     && mcpttUserProfile.getRuleset().getRule().size() > 0 && mcpttUserProfile.getRuleset().getRule().get(0) != null
                     && mcpttUserProfile.getRuleset().getRule().get(0).getActions() != null) {
 
                 if (mcpttUserProfile.getRuleset().getRule().get(0).getActions().isAllowprivatecall()) {

                     allowTypeEnumList.add(ConstantsMCOP.ConfigurationInfoEventExtras.McpttAllowTypeEnum.privateCallAllow);

                 }
                 if (mcpttUserProfile.getRuleset().getRule().get(0).getActions().isAllowemergencyprivatecall()) {

                     allowTypeEnumList.add(ConstantsMCOP.ConfigurationInfoEventExtras.McpttAllowTypeEnum.emergencyPrivateCallAllow);

                 }
                 if (mcpttUserProfile.getRuleset().getRule().get(0).getActions().isAllowemergencygroupcall()) {

                     allowTypeEnumList.add(ConstantsMCOP.ConfigurationInfoEventExtras.McpttAllowTypeEnum.emergencyGroupCallAllow);

                 }
                 if (mcpttUserProfile.getRuleset().getRule().get(0).getActions().isAllowimminentperilcall()) {

                     allowTypeEnumList.add(ConstantsMCOP.ConfigurationInfoEventExtras.McpttAllowTypeEnum.imminentPerilCallAllow);

                 }
                 if (mcpttUserProfile.getRuleset().getRule().get(0).getActions().isAllowactivateemergencyalert()) {

                     allowTypeEnumList.add(ConstantsMCOP.ConfigurationInfoEventExtras.McpttAllowTypeEnum.emergencyAlertActivateAllow);

                 }

                 event.putExtra(ConstantsMCOP.ConfigurationInfoEventExtras.MCPTT_ALLOWS_LIST ,ConstantsMCOP.ConfigurationInfoEventExtras.McpttAllowTypeEnum.getValue(allowTypeEnumList));

             }
 
         success = sendEvent(event);
     }
 
     private boolean sendConfigurationInfoError(Constants.ConstantsErrorMCOP.ConfigurationUpdateEventError configurationUpdateError){
         if(configurationUpdateError==null || mMCOPCallback==null ){
             if(BuildConfig.DEBUG) Log.e(TAG,"mMCOPCallback or configurationUpdateError is null");
             return false;
         }

         Intent event=new Intent(ConstantsMCOP.ActionsCallBack.configurationInfoEvent.toString());
         event.putExtra(ConstantsMCOP.ConfigurationInfoEventExtras.EVENT_TYPE,
                 ConstantsMCOP.ConfigurationInfoEventExtras.ConfigurationInfoEventTypeEnum.ConfigurationInfoError.toString());
 

         Log.e(TAG, "MbmsInfoEventError Error "+ configurationUpdateError.getCode()+": "+ configurationUpdateError.getString());
 
         //Error Code
         event.putExtra(ConstantsMCOP.EMBMSNotificationEventExtras.ERROR_CODE, configurationUpdateError.getCode());
         //Error String
         event.putExtra(ConstantsMCOP.EMBMSNotificationEventExtras.ERROR_STRING, configurationUpdateError.getString());
         return sendEvent(event);
     }
 
 
 

 }