/*

 *  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.doubango.ngn.services.impl.affiliation;
 
 import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
 import android.content.IntentFilter;
 import android.os.Handler;
 import android.os.Looper;
 import android.util.Log;
 
 import org.doubango.ngn.BuildConfig;
 import org.doubango.ngn.NgnApplication;
 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.Status;
 import org.doubango.ngn.datatype.affiliation.pidf.StatusType;
 import org.doubango.ngn.datatype.affiliation.pidf.Tuple;
 import org.doubango.ngn.services.affiliation.IMyAffiliationService;
 import org.doubango.ngn.sip.MyPublicationAffiliationSession;
 import org.doubango.ngn.sip.MySubscriptionAffiliationSession;
 import org.doubango.ngn.sip.NgnSipPrefrences;
 import org.doubango.utils.Utils;
 
 import java.util.ArrayList;
 import java.util.Calendar;
 import java.util.Date;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.TreeMap;
 
 
 public class MyAffiliationService implements IMyAffiliationService {
     private final static String TAG = Utils.getTAG(MyAffiliationService.class.getCanonicalName());
 
     private static boolean isStart;

     private BroadcastReceiver broadcastReceiverAffiliationMessage;

     private MySubscriptionAffiliationSession mSessionSuscription=null;
 
    private static final boolean USE_VERSION_OLD_AFFILIATION= false;
 
 
     public static final String AFFILIATION_REGISTER=TAG +".AFFILIATION_REGISTER";
     private Presence presenceNow=null;
     private Map<String,Presence> stringPresenceMap;
     private Map<Long,String> longStringMap;
     private OnAffiliationServiceListener onAffiliationServiceListener;
     private MyPublicationAffiliationSession mSessionPublication;
     private Map<String, Long> mGroupsMap;
     private TreeMap<Long, Map<String,String>> mExpiresMap;
     private Handler handlerService;
     private static final boolean checkExpiredActive=false;
     private Presence presenceNowDelay;
     private String pidNowDelay;
     private Map<String, String> expiresNowDelay;
     private CommandList commandListNowDelay;
     private Handler handlerStartAffiliation;
     private Runnable runnableStartAffiliation;
     private ArrayList affiliationGroupDelay;
     private boolean isSubscribed=false;
 
 
     @Override
     public boolean start() {
         Log.d(TAG,"Start "+"AffiliationService");
         stringPresenceMap=new HashMap<>();
         isStart=true;
         isSubscribed=false;
         broadcastReceiverAffiliationMessage=new BroadcastReceiver() {
             @Override
             public void onReceive(Context context, Intent intent) {
 
                 if (intent.getAction().equals(AFFILIATION_ACTION_MESSAGE)) {
                     Log.d(TAG,"New message received");
                     byte[] messageAffiliation=intent.getByteArrayExtra(AFFILIATION_NEWAFFILIATION_MESSAGE);
                     if(messageAffiliation==null || messageAffiliation.length==0){
                         Log.e(TAG,"Affiliation message not valid.");
                     }else{
                         Log.d(TAG,"Received new affiliation message.");
                         try {
                             CommandList commandList=AffiliationUtils.getCommandList(messageAffiliation);
                             receiveNewSelfAffiliation(commandList);
                         } catch (Exception e) {
                             Log.e(TAG,"Error parsing new message: "+e.toString()+" "+e.getMessage());
                         }
 
                     }
                 }else if (intent.getAction().equals(AFFILIATION_ACTION_NOTIFY)) {
                     Log.d(TAG,"New notify received.");
                     boolean sendAccound=false;
                     byte[] messageAffiliation=intent.getByteArrayExtra(AFFILIATION_NEWAFFILIATION_NOTIFY);
                     Log.d(TAG,"New notify affiliation received.");
                     //try {

                     Presence presence=null;
                     if(messageAffiliation==null || messageAffiliation.length==0){
                         Log.w(TAG,"Affiliation notify not valid or empty.");
                         presence=new Presence();
                     }else{
                         Log.d(TAG,"Valid affiliation notify.");
                         try {
                             if(BuildConfig.DEBUG)Log.d(TAG,"new notify: "+new String(messageAffiliation));
                             presence=AffiliationUtils.getPresence(messageAffiliation);
                         } catch (Exception e) {
                             Log.e(TAG,"Error proccess new affiliation:"+e.getMessage());

                         }

                     }
                     String mcpttID=null;
                     NgnSipPrefrences profile=NgnEngine.getInstance().getProfilesService().getProfileNow(context);
                     if(profile!=null)mcpttID=profile.getMcpttId();
                     if((presence!=null) && (mcpttID!=null) &&
                             (presence.getEntity()!=null) &&
                             (presence.getEntity().trim().compareTo(mcpttID.trim())==0)){
                         setPresenceNow(presence);
                         if(presence.getTuple()!=null && profile!=null){
                             if(!sendAccound){
                                 if(presence.getPId()!=null &&
                                         !presence.getPId().isEmpty() &&
                                         stringPresenceMap!=null &&
                                         stringPresenceMap.get(presence.getPId())!=null){
 
                                     receiveNewPresenceResponse(presence,presence.getPId());

                                 }else{

                                     receiveNewPresence(presence);

                                 }
                             }else{

                                 Log.d(TAG,"No listeners.");

                             }

                         }else{
                             Log.e(TAG,"Error processing affiliation data.");
                         }

                     }else if(presence!=null && mcpttID!=null &&
                             presence.getEntity()==null){
                         setPresenceNow(presence);
                         receiveNewPresence(presence);
                     }else{
                         Log.e(TAG,"Invalid new notify.");
                     }

                     /*
                     } catch (Exception e) {
                         Log.e(TAG,"it isn´t possible to parse the info on sip notify "+e.toString());
                     }
                     */
 
                 }else if (intent.getAction().equals(AFFILIATION_ACTION_SUBSCRIBE)) {
                     Log.d(TAG,"Receive response subscribe");
                     String error=intent.getStringExtra(AFFILIATION_RESPONSE_SUBSCRIBE_ERROR);
                     String responseOk=intent.getStringExtra(AFFILIATION_RESPONSE_SUBSCRIBE_OK);
                     if(error!=null){
                         //Error

                         Log.e(TAG,"Error in subscribe for affiliation "+error);

                         isSubscribed=false;
                     }else if(responseOk!=null){
                         //Ok
                         Log.d(TAG,"Correct subscribe for affiliation");
                         isSubscribed=true;
                         if(affiliationGroupDelay!=null){
                             Log.d(TAG,"Affiliation now to groups");
                             affiliationGroups(context,affiliationGroupDelay);
                             affiliationGroupDelay=null;
                         }
 
                     }else
                         Log.w(TAG,"This situation isn´t logic");
                 }else if (intent.getAction().equals(AFFILIATION_ACTION_UNSUBSCRIBE)) {
                     Log.d(TAG,"UnSubscribe");
                     isSubscribed=false;
                 }
             }
 
         };
         IntentFilter intentFilter = new IntentFilter();
         intentFilter.addAction(AFFILIATION_ACTION_MESSAGE);
         intentFilter.addAction(AFFILIATION_ACTION_NOTIFY);
         intentFilter.addAction(AFFILIATION_ACTION_SUBSCRIBE);
         intentFilter.addAction(AFFILIATION_ACTION_UNSUBSCRIBE);
         NgnApplication.getContext().registerReceiver(broadcastReceiverAffiliationMessage,intentFilter);

         return true;
     }
 
 
 
 
 
     @Override
     public boolean stop() {
         Log.d(TAG,"Stop "+"AffiliationService");
         stringPresenceMap=null;
         isSubscribed=false;
         unRegister();
         try{
             if(handlerService!=null && runnableStartAffiliation!=null){
                 handlerService.removeCallbacks(runnableStartAffiliation);
                 runnableStartAffiliation=null;
                 handlerService=null;
             }
         }catch (Exception e){
             Log.e(TAG,"Error in stop affiliation");
             e.printStackTrace();
         }
 
         isStart=false;
         return true;
     }
 
     public MyAffiliationService() {
 

     }
 
     private void affilitionChange(boolean isRegister){
         if(!isRegister){
             if(mSessionSuscription!=null){
                 Log.d(TAG,"Unsubscribe affiliation");
                 mSessionSuscription.unSubscribeAffiliation();
                 mSessionSuscription=null;
             }
         }else{
             mSessionSuscription= MySubscriptionAffiliationSession.createOutgoingSession(NgnEngine.getInstance().getSipService().getSipStack());
             if(mSessionSuscription.subscribeAffiliation()){
                 Log.d(TAG,"Subscribe sent.");
             }
         }
     }
 
     //INIT Publication
 
 
     public String unAffiliationGroup(Context context,String groupSusbcribe){
         if(context==null || groupSusbcribe==null)return null;
         ArrayList<String> groups=new ArrayList<>();
         groups.add(groupSusbcribe);
         Log.d(TAG,"Group unaffiliation initialized: "+groupSusbcribe);
         return unAffiliationGroups( context,groups);
     }
 
     public String unAffiliationGroups(Context context,List<String> groupsSusbcribe){
         if(groupsSusbcribe==null || groupsSusbcribe.isEmpty()){
             Log.e(TAG,"Invalid configuration.");
             return null;
         }
         byte[] bytes=null;
         Presence presence=null;
         if(!USE_VERSION_OLD_AFFILIATION){
             presence=generatePif(groupsSusbcribe,context,getPresenceNow(),false);
         }else{
             presence=generatePif(groupsSusbcribe,context);
         }

         if(presence!=null)

         try {
             bytes=AffiliationUtils.getBytesOfPresenceForAffiliation(context,presence);
         } catch (Exception e) {
             Log.e(TAG,"Invalid pidf+xml.");
             return null;
         }
         String impu=null;
         NgnSipPrefrences profileNow=NgnEngine.getInstance().getProfilesService().getProfileNow(context);
         if(profileNow!=null)impu=profileNow.getIMPU();
         if(mSessionPublication==null && impu!=null){
             mSessionPublication= MyPublicationAffiliationSession.createOutgoingSession(NgnEngine.getInstance().getSipService().getSipStack(),impu);
         }else{
             Log.d(TAG,"Publication is different than NULL.");
         }
         boolean result=false;
         if(!USE_VERSION_OLD_AFFILIATION){
             //use new version.
 
             if(bytes==null){
                 result=mSessionPublication.unPublish(bytes,context);
             }else{
                 result=mSessionPublication.publish(bytes,context);
             }
         }else{
             result=mSessionPublication.unPublish(bytes,context);
 
         }
         if(result && stringPresenceMap!=null){
             if(presence!=null){
                 stringPresenceMap.put(presence.getPId(),presence);
                 return presence.getPId();
             }else{
                 return "";
             }
         }else{
             Log.e(TAG,"Error sending publication.");
         }
         return null;
     }
 
 
     public String affiliationGroup(Context context,String groupSusbcribe){
         if(context==null || groupSusbcribe==null)return null;
         Log.d(TAG,"Init Affiliation->"+groupSusbcribe);
         ArrayList<String> groups=new ArrayList<>();
         groups.add(groupSusbcribe.trim());
         return affiliationGroups( context,groups);
     }
 
     public String affiliationGroups(Context context,List<String> groupsSusbcribe){
         if(groupsSusbcribe==null || groupsSusbcribe.isEmpty())return null;
 
         if(!isSubscribed){
             Log.d(TAG,"Now,it isn´t subcribe");
             if(affiliationGroupDelay==null)affiliationGroupDelay=new ArrayList();
             affiliationGroupDelay.addAll(groupsSusbcribe);
             return null;
         }
 
         byte[] bytes=null;
         Presence presence=generatePif(groupsSusbcribe,context,getPresenceNow(),true);
         try {
             bytes=AffiliationUtils.getBytesOfPresenceForAffiliation(context,presence);
         } catch (Exception e) {
             Log.e(TAG,"Invalid pidf+xml.");
             return null;
         }
 
         String impu=null;
         NgnSipPrefrences profileNow= NgnEngine.getInstance().getProfilesService().getProfileNow(context);
         if(profileNow!=null)impu=profileNow.getIMPU();
         if(bytes==null || bytes.length==0)return null;
         if(mSessionPublication==null && impu!=null)
             mSessionPublication= MyPublicationAffiliationSession.createOutgoingSession(NgnEngine.getInstance().getSipService().getSipStack(),impu);
         boolean result=mSessionPublication.publish(bytes,context);
         if(result){
             stringPresenceMap.put(presence.getPId(),presence);
             return presence.getPId();
         }
         return null;
     }
 
     /**
      * @param groupsSusbcribe
      * @param context
      * @return
      */
     private Presence generatePif(List<String> groupsSusbcribe,Context context){
        return generatePif(groupsSusbcribe,context,null,true);
     }
 
     /**
      * Function to create the PIF (generate new pif or use an old pif+xml).
      * @param groupsSusbcribe
      * @param context
      * @param presence
      * @return
      */
     private  Presence generatePif(List<String> groupsSusbcribe,Context context,Presence presence,boolean affiliate){
         if(groupsSusbcribe==null || groupsSusbcribe.isEmpty())return null;
         ArrayList<AffiliationType> affiliationTypes;
         Tuple tuple;
         Status status;
 
         if(presence!=null && presence.getTuple()!=null &&
                 presence.getTuple().size()>0 &&
                 (tuple=presence.getTuple().get(0))!=null &&
                 (status=tuple.getStatus())!=null &&

                 (status.getAffiliations()!=null) && (new ArrayList<>(status.getAffiliations()))!=null

                 ){
             Log.d(TAG,"Using the old presence.");
         }else{
             if(presence==null){
                 Log.d(TAG,"Generating new presence for affiliation process.");
             }else{
                 Log.e(TAG,"Invalid current presence. New one generated.");
             }
 
         }
 
         String mcpttID=null;
         Presence presence2=new Presence();
         NgnSipPrefrences profileNow= NgnEngine.getInstance().getProfilesService().getProfileNow(context);
         if(profileNow!=null)mcpttID=profileNow.getMcpttId();
         presence2.setEntity(mcpttID);
         tuple=new Tuple();
         String mcpttClientID=null;
         if(profileNow!=null)mcpttClientID=profileNow.getMcpttClientId();
         tuple.setId(mcpttClientID);
         status=new Status();
         affiliationTypes=new ArrayList<>();
         status.setAffiliations(affiliationTypes);
         tuple.setStatus(status);
         ArrayList<Tuple> tuples=new ArrayList<>();
         tuples.add(tuple);
         String pid=mcpttID+Calendar.getInstance().getTimeInMillis();
         presence2.setPId(pid);
         presence2.setTuple(tuples);

         Tuple tupleRemote=null;

         if(affiliate){
             if(presence!=null && presence.getTuple()!=null &&

                     presence.getTuple().size()>0)
             for(Tuple tupleRemote2:presence.getTuple()){
                 if(profileNow.getMcpttClientId()!=null && tupleRemote2.getId()!=null && tupleRemote2.getId().compareTo(profileNow.getMcpttClientId())==0){
                     tupleRemote=tupleRemote2;
                 }
             }
             if((tupleRemote!=null &&
                     (status=tupleRemote.getStatus())!=null
                     && status.getAffiliations()!=null
                     )){
                 affiliationTypes=new ArrayList<>(status.getAffiliations());

 
             }else{
                 affiliationTypes=new ArrayList<>();
             }
             for(String group:groupsSusbcribe){

                 if(/*AffiliationUtils.isValidURISIP(group) &&*/ checkGroupStatus(affiliationTypes,group)<0){

                     AffiliationType affiliationType=new AffiliationType();
                     affiliationType.setGroup(group);
                     affiliationTypes.add(affiliationType);
                 }
             }
             presence2.getTuple().get(0).getStatus().setAffiliations(createListAffiliationType(affiliationTypes));
         }else{
             //unaffiliate

 
             if(presence!=null){
                 affiliationTypes=new ArrayList<>(presence.getTuple().get(0).getStatus().getAffiliations());
             }else{
                 affiliationTypes=new ArrayList<>();
             }

             for(String group:groupsSusbcribe){
                 int index=-1;
                 if((index=checkGroupStatus(affiliationTypes,group))>=0 && affiliationTypes.size()>index){
                     Log.d(TAG,"unaffiliate");
                     affiliationTypes.remove(index);
                 }else{
                     Log.e(TAG,"Error unaffiliating "+index);
                 }
             }
             if(affiliationTypes.size()==0){
                 Log.d(TAG,"Device does not have any affiliation group.");
                 return null;
             }
             presence2.getTuple().get(0).getStatus().setAffiliations(createListAffiliationType(affiliationTypes));
             if(affiliationTypes.size()==0){
                 presence2=null;
             }
         }
 
 
         return presence2;
     }
 
     private int checkGroupStatus(ArrayList<AffiliationType> affiliationTypes,String group){
         if(group==null && affiliationTypes==null){
             Log.e(TAG, "Error checking group affiliations parameters.");
             return -1;
         }
         if(affiliationTypes!=null){
             for(int con=0;con<affiliationTypes.size();con++){
                 if(affiliationTypes.get(con).getGroup().compareTo(group)==0){
                     return con;
                 }
             }
         }
 
         return -1;
 
     }
 
     private  List<AffiliationType> createListAffiliationType( List<AffiliationType> affiliationTypes){
         ArrayList<AffiliationType> result=new ArrayList<>();
         for(AffiliationType affiliationType:affiliationTypes){
             result.add(new AffiliationType(affiliationType.getGroup()));
         }
         return result;
     }
 
     //END Publication
 
     //INIT service affiliation
 
 
     /**
      * Executed when the service starts
      */
     public void startServiceAffiliation(Context context){
         //Start Service
 
         if(isAffiliation(context)){
             affilitionChange(true);
         }
     }
 
     /**
      * Executed when the service starts
      */
     public void startServiceAffiliation(){
         //Start Service
         Log.d(TAG,"Start affiliation service.");
         handlerStartAffiliation = new Handler(Looper.getMainLooper());
         runnableStartAffiliation=new Runnable() {
             @Override
             public void run() {
                 if(isAffiliation(NgnApplication.getContext())){
                     affilitionChange(true);
                 }
             }
         };
         handlerStartAffiliation.postDelayed(runnableStartAffiliation, DELAY_ACTION_AFFILIATION_MSEC);
     }
 
     /**
      * Executed when the service stops
      */
     public void stopServiceAffiliation(){
         //Stop Serveice
         //affilitionChange(false);
     }
 
 
 
     private void unRegister(){
         try {

             if(broadcastReceiverAffiliationMessage!=null){
                 NgnApplication.getContext().unregisterReceiver(broadcastReceiverAffiliationMessage);
                 broadcastReceiverAffiliationMessage=null;
             }
             if(BuildConfig.DEBUG)Log.d(TAG,"Unregisted: broadcastReceiverAffiliationMessage");

         }catch (Exception e){
             Log.e(TAG,"Error1:"+e.getMessage());
         }
 
     }
 
     public Presence getPresenceNow() {
         return presenceNow;
     }
 
     public void setPresenceNow(Presence presenceNow) {
         this.presenceNow = presenceNow;
     }
 
     public void setOnAffiliationServiceListener(OnAffiliationServiceListener onAffiliationServiceListener){
         this.onAffiliationServiceListener=onAffiliationServiceListener;
 
     }
 
     //Init affiliation action
     private void receiveNewPresence(Presence presence) {
         if(BuildConfig.DEBUG)Log.d(TAG,"receiveNewPresence");
         if(onAffiliationServiceListener!=null){
             onAffiliationServiceListener.receiveNewPresence( presence);
         }else{
             if(BuildConfig.DEBUG)Log.d(TAG,"No define interface affiliation");
         }
     }
 
     private void receiveNewPresenceResponse(Presence presence, String pid) {
         if(BuildConfig.DEBUG)Log.d(TAG,"receiveNewPresence:"+pid);
         presenceNowDelay=presence;
         pidNowDelay=pid;
         if(onAffiliationServiceListener!=null){
             onAffiliationServiceListener.receiveNewPresenceResponse( presenceNowDelay, pidNowDelay);
         }else{
             if(BuildConfig.DEBUG)Log.d(TAG,"No define interface affiliation");
         }
     }
 
     private void expireAffiliations(Map<String, String> expires) {
         expiresNowDelay=expires;
         if(onAffiliationServiceListener!=null)onAffiliationServiceListener.expireAffiliations(expiresNowDelay);
     }
 
     private void receiveNewSelfAffiliation(CommandList commandList) {
         commandListNowDelay=commandList;
         if(onAffiliationServiceListener!=null)onAffiliationServiceListener.receiveNewSelfAffiliation( commandListNowDelay);
     }
 
     private void startNewService() {
         if(onAffiliationServiceListener!=null)onAffiliationServiceListener.startNewServiceAffiliation();
 
     }
     //end affiliation action
 
 
 
 
     //END service affiliation
 
     //INIT affiliation automatically
 
     public void processingCommandList(Context context,CommandList commandList){
         if(commandList==null || !AffiliationUtils.isSelfAffiliation(context)){
             return;
         }
         //Send to GUI from the client.
         //Affiliation
         if(commandList.getAffiliate()!=null && commandList.getAffiliate().getGroup()!=null){
             List<String> groups=AffiliationUtils.isValidURIsSIP(new ArrayList<String>(commandList.getAffiliate().getGroup()));
             if(groups!=null)affiliationGroups(context,groups);
         }
         //Deaffiliation
         if(commandList.getDeAffiliate()!=null && commandList.getDeAffiliate().getGroup()!=null){
             List<String> groups=AffiliationUtils.isValidURIsSIP(new ArrayList<String>(commandList.getDeAffiliate().getGroup()));
             if(groups!=null)unAffiliationGroups(context,groups);
         }
     }
 
     //END affiliation automatically
 
     //INIT checkExpire
     private void checkExpire(){
         if(isCheckExpiredActive()) {
             handlerService = new Handler();
             handlerService.postDelayed(new Runnable() {
                 @Override
                 public void run() {
                     if (isStart && mExpiresMap.size() > 0) {
                         checkExpire();
                     }
                 }
             }, DEFAULT_SECOS_BETWEEN_CHECK_EXPIRES * 1000);
             checkExpire(Calendar.getInstance().getTime());
         }
     }
     private void checkExpire(Date date){
         Map<String,String> expires=new HashMap<>();
         expires=checkExpire(date,expires);
         if(expires!=null && expires.size()>0){
            expireAffiliations(expires);
         }
     }
 
     private Map<String,String> checkExpire(Date date,Map<String,String> expires){
         if(mExpiresMap==null)return null;
         Map.Entry<Long, Map<String,String>> hashMapEntry= mExpiresMap.firstEntry();
         if(hashMapEntry==null)return expires;
         Long time=hashMapEntry.getKey();
         if(date.getTime()>=time){
             Map<String,String> arrayList=hashMapEntry.getValue();
             if(arrayList!=null)arrayList.putAll(expires);
             mExpiresMap.remove(time);
             return checkExpire(date,arrayList);
         }else{
             return expires;
         }
     }
     public void addNewOrChangeTimeExpire(List<AffiliationType> affiliationTypes){
         mExpiresMap=new TreeMap<>();
         if(affiliationTypes==null)return;
         for(AffiliationType  affiliationType:affiliationTypes){
             if(affiliationType!=null && affiliationType.getStatus()== StatusType.affiliated){
                 String group=affiliationType.getGroup();
                 Date date=affiliationType.getExpiresDate();
                 if(group!=null && date!=null){
                     Map<String,String> strings=mExpiresMap.get(date.getTime());
                     if(strings==null){
                         strings=new HashMap<>();
                         mExpiresMap.put(date.getTime(),strings);
                     }
                     strings.put(group,group);
                 }
 
             }
         }
         checkExpire();
     }
     //END checkExpire
 
 
     private boolean isCheckExpiredActive() {
         return checkExpiredActive;
     }
 
     public boolean isAffiliation(Context context){
         NgnSipPrefrences profileNow=NgnEngine.getInstance().getProfilesService().getProfileNow(context);
         if(profileNow==null || profileNow.isMcpttIsEnableAffiliation()==null)return false;
         return profileNow.isMcpttIsEnableAffiliation();
     }
 
     @Override
     public boolean clearService(){
         Log.d(TAG,"Clear:  "+"LocalizationService");
         if(presenceNow!=null)presenceNow=null;
         return true;
     }
 }