/*

 *  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.mbms;
 
 import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
 import android.content.IntentFilter;
 import android.content.pm.PackageManager;
 import android.os.IBinder;
 import android.util.Log;
 
 import org.doubango.ngn.BuildConfig;
 import org.doubango.ngn.NgnApplication;
 import org.doubango.ngn.datatype.mbms.MbmsData;
 import org.doubango.ngn.datatype.mbms.McpttMbmsUsageInfoType;
 import org.doubango.ngn.events.NgnEventArgs;
 import org.doubango.ngn.events.NgnMcpttMbmsEventArgs;
 import org.doubango.ngn.events.NgnMcpttMbmsEventTypes;
 import org.doubango.ngn.services.mbms.IMyMbmsService;
 import org.doubango.ngn.sip.NgnAVSession;
 import org.doubango.ngn.utils.NgnObservableHashMap;
 import org.doubango.utils.Utils;
 
 import java.net.MalformedURLException;
 import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Set;
 
 
 //TODO:At the moment only MBMS service works with a single session of MCPTT group. But in the future is nesitaria that would work with N sessions simultaneous.
 public class MyMbmsService implements
         IMyMbmsService,
         MyMbmsExtensionService.MyMbmsExtenxionServiceListener
         {
     private final static String TAG = Utils.getTAG(MyMbmsService.class.getCanonicalName());
 
     private final BroadcastReceiver broadcastReceiverMbmsInfo;
     private final BroadcastReceiver broadcastReceiverMbmsControl;
     private final MyMbmsExtensionService mbmsExtensionService;
     private int[] currentServiceArea;
     private IBinder mService;
     private boolean isBound;
     private OnMbmsListener onMbmsListener;
 
     protected static final String[] DEFAULT_SERVICE_CLASS_TYPES = {};
     private MbmsExternalServiceListener mbmsExternalServiceListener;
 
             @Override
     public boolean start() {
         Log.d(TAG, "Start " + "MbmsService");
         //Start services mbms
         try {
             startServer(NgnApplication.getContext());
         }catch (Exception e){
             if(BuildConfig.DEBUG)Log.w(TAG,"MBMS error:"+e.getMessage());
         }
         //Start client eMBMS
         try {
             startClient(NgnApplication.getContext());
         } catch (Exception e) {
             Log.e(TAG,"Error start client mbms "+e.getMessage());
         }
         return true;
     }
 
     @Override
     public boolean stop() {
         Log.d(TAG, "Stopped " + "MbmsService");
         //Stop client eMBMS
         try {
             stopClient(NgnApplication.getContext());
         } catch (Exception e) {
             Log.e(TAG,"Error stop client mbms "+e.getMessage());
         }
         //Stop services mbms
         try {
             stopServer(NgnApplication.getContext());
             stopServiceMbms();
         }catch (Exception e){
             Log.e(TAG,"Error in MBMS servide"+e.getMessage());
         }
         return true;
     }
 
     public MyMbmsService() {
         mbmsExtensionService=new MyMbmsExtensionService();
         mbmsExtensionService.setMyMbmsExtenxionServiceListener(this);
         broadcastReceiverMbmsInfo = new BroadcastReceiver() {
             @Override
             public void onReceive(Context context, Intent intent) {
                 Log.d(TAG, "New message received.");
                 if (intent.getAction().equals(MBMS_ACTION)) {
                     byte[] mbmsListeningStatusType = intent.getByteArrayExtra(MBMS_NEWMESSAGE_MBMS);
                     int portMBMSManager = intent.getIntExtra(MBMS_PORT_MANAGER_MBMS, MBMS_DEFAULT_INT);
                     String ipMBMSManager = intent.getStringExtra(MBMS_IP_MANAGER_MBMS);
                     String pAssertedIdentity = intent.getStringExtra(MBMS_P_ASSERTED_IDENTITY);
                     if (mbmsListeningStatusType == null ||
                             mbmsListeningStatusType.length == 0 ||
                             portMBMSManager == MBMS_DEFAULT_INT ||
                             ipMBMSManager == null ||
                             ipMBMSManager.isEmpty()||
                             pAssertedIdentity==null||
                             pAssertedIdentity.isEmpty()) {
                         Log.e(TAG, "Invalid MBMS info.");
                     } else {
                         /*
                             Configurated with new Message
                          */
                         configureNewServiceMbms(mbmsListeningStatusType, portMBMSManager, ipMBMSManager,pAssertedIdentity);
                     }
                 }else if(intent.getAction().equals(MBMS_SESSION_ID_ACTION)){
                     String sessionID=intent.getStringExtra(MBMS_SESSION_ID_MBMS);
                     if(sessionID!=null && !sessionID.isEmpty()){
                         Log.d(TAG,"Set call ID Session.");
                         if(mbmsExtensionService!=null)
                         mbmsExtensionService.setSessionIdCurrent(sessionID.replace("<","").replace(">","").replace("gr","").replace(";",""));
                     }
                 }else if(intent.getAction().equals(MBMS_MEDIA_ACTION)){{
                     Log.d(TAG,"MBMS media parameters received.");

                     if(intent.getBooleanExtra(MBMS_MAP_MBMS,true)){
                         String groupID=intent.getStringExtra(MBMS_GROUP_ID_MBMS);
                         String ipMedia=intent.getStringExtra(MBMS_IP_MEDIA_MBMS);
                         long tmgi=intent.getLongExtra(MBMS_TMGI_MBMS,MBMS_DEFAULT_INT);
                         int portMedia=intent.getIntExtra(MBMS_PORT_MEDIA_MBMS,MBMS_DEFAULT_INT);
                         int portControlMedia=intent.getIntExtra(MBMS_PORT_CONTROL_MEDIA_MBMS,MBMS_DEFAULT_INT);
                         if(ipMedia!=null &&
                                 !ipMedia.isEmpty()&&
                                 tmgi!=MBMS_DEFAULT_INT &&
                                 portControlMedia!=MBMS_DEFAULT_INT &&
                                 portMedia!=MBMS_DEFAULT_INT){
                             Log.d(TAG,"MBMS IP and Port configured.");
                             MbmsData mbmsData=null;
                             if((mbmsData=getMbmsDataOfTmgi(tmgi))!=null){
                                 mbmsData.setIpMulticastMedia(ipMedia);
                                 mbmsData.setPortMulticastMedia(portMedia);
                                 mbmsData.setPortControlMulticastMedia(portControlMedia);
                                 mbmsData.setGroupID(groupID);
                                 checkTMGItoListening(tmgi,context);
                             }

                         }

                     }else{
                         //TODO: for UNMAP

                     }

                 }}
             }
         };
         IntentFilter intentFilter = new IntentFilter();
         intentFilter.addAction(MBMS_ACTION);
         intentFilter.addAction(MBMS_SESSION_ID_ACTION);
         intentFilter.addAction(MBMS_MEDIA_ACTION);
         NgnApplication.getContext().registerReceiver(broadcastReceiverMbmsInfo, intentFilter);
 
         broadcastReceiverMbmsControl = new BroadcastReceiver() {
             @Override
             public void onReceive(Context context, Intent intent) {
                 final String action = intent.getAction();

                 long tmgi;
                 String ipMedia;

                 String groupID;

                 int portMedia;
                 int portControlMedia;

                 Intent intentMediaAct=new Intent();

                 // Registration Event
                 if(NgnMcpttMbmsEventArgs.ACTION_MCPTT_MBMS_EVENT.equals(action)){
                     Log.d(TAG,"MBMS Control EVENT.");
                     NgnMcpttMbmsEventArgs args = intent.getParcelableExtra(NgnEventArgs.EXTRA_EMBEDDED);
                     final NgnMcpttMbmsEventTypes type;
                     if(args == null){
                         Log.e(TAG, "Invalid event args.");
                         return;
                     }else{
                         Log.d(TAG, "MCPTT MBMS event args.");
                     }
                     switch((type = args.getEventType())){
                         case MAP_GROUP:
 
                             Log.d(TAG, "MBMS GROUP MAPPED");

                             groupID=intent.getStringExtra(NgnMcpttMbmsEventArgs.EXTRA_GROUP);

                             tmgi = intent.getLongExtra(NgnMcpttMbmsEventArgs.EXTRA_TMGI,-1);
                             ipMedia = intent.getStringExtra(NgnMcpttMbmsEventArgs.EXTRA_MEDIA_IP);
                             portMedia = intent.getShortExtra(NgnMcpttMbmsEventArgs.EXTRA_MEDIA_PORT, new Short("-1"));
                             portControlMedia = intent.getShortExtra(NgnMcpttMbmsEventArgs.EXTRA_MEDIA_CTRL_PORT, new Short("-1"));
 

 
                             intentMediaAct.putExtra(MBMS_GROUP_ID_MBMS,groupID);
                             intentMediaAct.putExtra(MBMS_MAP_MBMS,true);

                             intentMediaAct.putExtra(MBMS_IP_MEDIA_MBMS,ipMedia);
                             intentMediaAct.putExtra(MBMS_PORT_CONTROL_MEDIA_MBMS,portControlMedia);
                             intentMediaAct.putExtra(MBMS_PORT_MEDIA_MBMS,portMedia);
                             intentMediaAct.putExtra(MBMS_TMGI_MBMS,tmgi);
                             intentMediaAct.setAction(MBMS_MEDIA_ACTION);
                             NgnApplication.getContext().sendBroadcast(intentMediaAct);
 
                             break;
                         case UNMAP_GROUP:
                             Log.d(TAG, "MBMS GROUP UNMAPPED");

                             groupID=intent.getStringExtra(NgnMcpttMbmsEventArgs.EXTRA_GROUP);
                             intentMediaAct.putExtra(MBMS_MAP_MBMS,false);
                             intentMediaAct.putExtra(MBMS_GROUP_ID_MBMS,groupID);
                             intentMediaAct.setAction(MBMS_MEDIA_ACTION);
 
                             NgnApplication.getContext().sendBroadcast(intentMediaAct);

 
                             break;
                        default:
                             Log.d(TAG, "Invalid event.");
                             break;
                     }
 
 
                 }
             }
         };
         final IntentFilter intentFilter2 = new IntentFilter();
         intentFilter2.addAction(NgnMcpttMbmsEventArgs.ACTION_MCPTT_MBMS_EVENT);
         NgnApplication.getContext().registerReceiver(broadcastReceiverMbmsControl, intentFilter2);
 
     }
 
     //INIT service location
 
 
 
     /**
      * Executed when new service configuration received
      * TODO: This method is where you must create logic to listen to from the network the TMGIs and the related SAIs
      * @param mcpttMbmsUsageInfoTypeBytes
      */
     private boolean configureNewServiceMbms(byte[] mcpttMbmsUsageInfoTypeBytes, int portMBMSManager, String ipMBMSManager,String pAssertedIdentity) {
         if(BuildConfig.DEBUG)Log.i(TAG,"configureNewServiceMbms portMBMSManager:"+portMBMSManager+ " ipMBMSManager:"+ipMBMSManager);
         McpttMbmsUsageInfoType mcpttMbmsUsageInfoType = MbmsUtils.getMcpttMbmsUsageInfoType(mcpttMbmsUsageInfoTypeBytes);
         if (mcpttMbmsUsageInfoType != null) {
             //check if mbmsListeningStatusType is listening or not
             mcpttMbmsUsageInfoType.getAnnouncement().getMbmsServiceAreas();
             MbmsData mbmsData=null;
             if (mbmsExtensionService != null &&
                     mcpttMbmsUsageInfoType.getAnnouncement() != null &&
                     mcpttMbmsUsageInfoType.getAnnouncement().getMbmsServiceAreas() != null &&
                     !mcpttMbmsUsageInfoType.getAnnouncement().getMbmsServiceAreas().trim().isEmpty()) {
                 if (mcpttMbmsUsageInfoType.getAnnouncement().getMbmsServiceAreas().trim().equals(MBMS_SERVICE_AREA_CANCELL)) {
                     Log.d(TAG, "Delete all service area MBMS.");
                     stopMbmsManagerListening();
                     mbmsExtensionService.deleteActiveMcpttMbmsUsageInfoType();
                     mbmsExtensionService.deleteActiveMcpttMbmsUsageInfoTypeforTMGI();
                 } else{
                     Log.d(TAG, "Add new service area MBMS.");
                     mbmsData = new MbmsData(mcpttMbmsUsageInfoType, portMBMSManager, ipMBMSManager,pAssertedIdentity);
                     putMbmsData(mbmsData);
                     //This will be done when the stream is opened
                     // startMbmsManagerListening(mbmsData);
                 }
             }
 
             return true;
         } else {
             Log.e(TAG, "Unable to configure MBMS server.");
             return false;
         }
     }
     @Override
     public void startMbmsManagerListening(MbmsData mbmsData){
         //TODO: start Listening MBMS manager
         Log.d(TAG,"MyMbmsService. Starting MBMS manager. IP=" + mbmsData.getIpMBMSManager() + " Port=" + mbmsData.getPortMBMSManager() + " Interface=" + mbmsData.getLocalInterface() + " Index=" + mbmsData.getLocalInterfaceIndex());
         /*
         Intent intent=new Intent();
         intent.putExtra(MyMbmsService.MBMS_IP_MANAGER_MBMS, mbmsData.getIpMBMSManager());
         intent.putExtra(MyMbmsService.MBMS_PORT_MANAGER_MBMS, mbmsData.getPortMBMSManager());
         intent.putExtra(MyMbmsService.MBMS_LOCAL_IFACE, mbmsData.getLocalInterface());
         intent.putExtra(MyMbmsService.MBMS_LOCAL_IFACE_INDEX, mbmsData.getLocalInterfaceIndex());
         intent.setAction(MyMbmsService.MBMS_CALL_ACTION_MANAGER_START);
         NgnApplication.getContext().sendBroadcast(intent);
         */
         //TODO: it is necessary send for all sessions:
         NgnObservableHashMap<Long, NgnAVSession> sessions = NgnAVSession.getSessions();
         if(sessions!=null && !sessions.isEmpty())
         for(NgnAVSession session:sessions.values()){
             if(session.isActive() && session.isConnected() && session.startMbmsManager(mbmsData.getIpMBMSManager(),mbmsData.getPortMBMSManager(), mbmsData.getLocalInterface(),mbmsData.getLocalInterfaceIndex())){
                 if(BuildConfig.DEBUG)Log.i(TAG,"execute ok startMbmsManager in session id:"+session.getId());

             }else{
                 if(BuildConfig.DEBUG)Log.e(TAG,"No correct execute startMbmsManager in session id:"+session.getId());
             }
         }
     }
 
     @Override

     public void stopMbmsManagerListening(MbmsData mbmsData) {
 //TODO: start Listening MBMS manager
         Log.d(TAG,"MyMbmsService. Stopping MBMS manager. IP=" + mbmsData.getIpMBMSManager() + " Port=" + mbmsData.getPortMBMSManager() + " Interface=" + mbmsData.getLocalInterface() + " Index=" + mbmsData.getLocalInterfaceIndex());
         //TODO: it is necessary send for all sessions:
         NgnObservableHashMap<Long, NgnAVSession> sessions = NgnAVSession.getSessions();
         if(sessions!=null && !sessions.isEmpty())
             for(NgnAVSession session:sessions.values()){
                 if(session.stopMbmsManager()){
                     if(BuildConfig.DEBUG)Log.i(TAG,"execute ok stopMbmsManager in session id:"+session.getId());
                 }else{
                     if(BuildConfig.DEBUG)Log.e(TAG,"No correct execute stopMbmsManager in session id:"+session.getId());
                 }
             }
     }
 
     @Override

     public void startMbmsManager(String  interfaceNet,long tmgi){
         if(mbmsExtensionService!=null)mbmsExtensionService.startMbmsManager(interfaceNet,tmgi);
     }
 
     @Override

     public void stopMbmsManager(long tmgi){
         if(mbmsExtensionService!=null)mbmsExtensionService.stopMbmsManager(tmgi);
     }
 
 
     @Override

     public List<Long> getTMGIs(int serviceAreaID) {
         return mbmsExtensionService.getTMGIs(serviceAreaID);
     }
 
     @Override
     public int[] getSais(long TMGI) {
         return mbmsExtensionService.getSais(TMGI);
     }
 
     @Override
     public int[] getFrequencies(long TMGI) {
         return mbmsExtensionService.getFrequencies(TMGI);
     }
 
             @Override
     public void startedClient(boolean status) {
         if(mbmsExternalServiceListener!=null)mbmsExternalServiceListener.startedClient(status);
     }
 
     @Override
     public void startedServer(boolean status) {
         if(mbmsExternalServiceListener!=null)mbmsExternalServiceListener.startedServer(status);
     }
 
     @Override
     public boolean mbmsListeningServiceAreaCurrent(long TMGI,  int[] sai,  int[] frequencies) {
         if(mbmsExternalServiceListener!=null)return mbmsExternalServiceListener.mbmsListeningServiceAreaCurrent( TMGI,   sai,   frequencies);
         return false;
     }
 
 
 
     private void putMbmsData(MbmsData mbmsData){
         if(mbmsExtensionService!=null)
         mbmsExtensionService.putMbmsData(mbmsData);
 
         if(onMbmsListener!=null &&
                 mbmsData.getMcpttMbmsUsageInfoType()!=null &&
                 mbmsData.getMcpttMbmsUsageInfoType().getAnnouncement()!=null){
             onMbmsListener.onNewServiceArea(
                     mbmsData.getMcpttMbmsUsageInfoType().getAnnouncement().getTMGIBigInteger()!=null?mbmsData.getMcpttMbmsUsageInfoType().getAnnouncement().getTMGIBigInteger().longValue():-1,
                     mbmsData.getMcpttMbmsUsageInfoType().getAnnouncement().getMbmsServiceAreasArrayInteger(),
                     mbmsData.getMcpttMbmsUsageInfoType().getAnnouncement().getFrequencyArrayInteger(),
                     mbmsData.getMcpttMbmsUsageInfoType().getAnnouncement().getQCI()!=null? mbmsData.getMcpttMbmsUsageInfoType().getAnnouncement().getQCI().longValue():-1);
         }
     }
 
 
 
     private void stopMbmsManagerListening(){
         //TODO: stop Listening MBMS manager
         Log.d(TAG, "Stopping MBMS manager");
         Intent intent=new Intent();
         intent.setAction(MyMbmsService.MBMS_CALL_ACTION_MANAGER_STOP);
         NgnApplication.getContext().sendBroadcast(intent);
     }
 
     /**
      * If the device is in service area, it will return true
      *
      * @return
      */
     private boolean checkServiceArea(Context context) {
         if (mbmsExtensionService == null || mbmsExtensionService.getActiveMcpttMbmsUsageInfoType().isEmpty() || currentServiceArea == null) {
             Log.e(TAG,"Parameters MBMS is not valid.");
             return false;
         }
         ArrayList<MbmsData> mbmsDatas = mbmsExtensionService.getMbmsDataOfServiceArea(currentServiceArea);
         for(MbmsData mbmsData:mbmsDatas){
             if (mbmsData != null || mbmsData.getMcpttMbmsUsageInfoType() != null ) {
                 Log.d(TAG, "Device has current service area MBMS.");
                 if(mbmsExtensionService!=null)
                     mbmsExtensionService.sendMbmsListeningServiceAreaCurrent(mbmsData,true,context);
                 return true;
             }
             Log.d(TAG, "Device does not have current service area MBMS.");
         }
 
         return false;
     }
 
 
 
     /**
      * it receive new service area, change in SAI
      * @param currentServiceArea
      * @return
      */
     @Override
     public boolean onChangeServiceArea(int[] currentServiceArea,Context context){
         if(currentServiceArea==null || currentServiceArea.length==0){
             Log.e(TAG,"The new Service Area MBMS isn´t valid");
             return false;
         }else{
             this.currentServiceArea=currentServiceArea;
             boolean control=checkServiceArea(context);
             if(control){
                 Log.d(TAG,"Checked service area.");
             }else {
                 Log.e(TAG,"Error checking service area.");
             }
             return control;
         }
 
     }
 
     /**
      * New service area received
      * TODO: Temporal function
      * @param tmgi
      * @return
      */
     @Override
     public void onReceiveMCCP(String tmgi,String ipMedia,int portMedia,int portControlMedia,Context context){
         if(tmgi==null || tmgi.trim().isEmpty()){
             Log.e(TAG,"New tmgi invalid.");
             return ;
         }else{
             Log.d(TAG,"Receive");
             Intent intent=new Intent();
             intent.putExtra(MyMbmsService.MBMS_IP_MEDIA_MBMS,ipMedia);
             intent.putExtra(MyMbmsService.MBMS_PORT_CONTROL_MEDIA_MBMS,portControlMedia);
             intent.putExtra(MyMbmsService.MBMS_PORT_MEDIA_MBMS,portMedia);
             intent.putExtra(MyMbmsService.MBMS_TMGI_MBMS,tmgi);
             intent.setAction(MyMbmsService.MBMS_MEDIA_ACTION);
             context.sendBroadcast(intent);
 
 
 
             return;
         }
     }
     @Override
     public MbmsData getMbmsDataOfTmgi(long tmgi){
         if(mbmsExtensionService!=null)
         return mbmsExtensionService.getMbmsDataOfTmgi(tmgi);
         return null;
     }
 

     private MbmsData getMbmsDataOfTmgi(String groupID){
         if(mbmsExtensionService!=null)
             return mbmsExtensionService.getMbmsDataOfTmgi(groupID);
         return null;
     }
 
 

     /**
      * If the device is in tmgi, it will return true
      *
      * @return
      */
     private boolean checkTMGItoListening(long tmgi,Context context) {
         if (mbmsExtensionService == null || mbmsExtensionService.getActiveMcpttMbmsUsageInfoType().isEmpty()) {
             Log.e(TAG,"MBMS parameters invalid.");
             return false;
         }
         MbmsData mbmsData = getMbmsDataOfTmgi(tmgi);
         if (mbmsData != null || mbmsData.getMcpttMbmsUsageInfoType() != null) {
             Log.e(TAG, "Message as TMGI.");

             if(listeningMulticast(tmgi,mbmsData,true) && mbmsExtensionService!=null){

                 mbmsExtensionService.sendMbmsListeningServiceAreaCurrent(mbmsData,true,context);
                 return true;
             }
 
         }
         return false;
     }
 

     private boolean listeningMulticast(long tmgi,MbmsData mbmsData,boolean start){

         //TODO: init listening media for MBMS audio in IP address Multicast
         boolean ret = true;
         if (start) {
             Log.d(TAG, "Start listening MBMS media.");
             /*
             Intent intent=new Intent();
             intent.putExtra(MyMbmsService.MBMS_IP_MEDIA_MBMS, mbmsData.getIpMulticastMedia());
             intent.putExtra(MyMbmsService.MBMS_PORT_MEDIA_MBMS, mbmsData.getPortMulticastMedia());
             intent.putExtra(MyMbmsService.MBMS_PORT_CONTROL_MEDIA_MBMS, mbmsData.getPortControlMulticastMedia());
             intent.setAction(MyMbmsService.MBMS_CALL_ACTION_MEDIA_START);
             NgnApplication.getContext().sendBroadcast(intent);
             */

             //TODO: it is necessary send for only any session:

             NgnObservableHashMap<Long, NgnAVSession> sessions = NgnAVSession.getSessions();
             if(sessions!=null && !sessions.isEmpty())

                 if(BuildConfig.DEBUG && mbmsData.getGroupID()!=null)
                     Log.d(TAG,"Start multicast Group ID: "+mbmsData.getGroupID());
 

                 for(NgnAVSession session:sessions.values()) {

                     String mcpttGroupIdentity=session.getPTTMcpttGroupIdentity();
                     if (session.isActive() &&
                             session.isConnected() &&
                             mcpttGroupIdentity!=null &&
                             mcpttGroupIdentity.trim().compareTo(mbmsData.getGroupID().trim())==0 &&
                             session.startMbmsMedia( mbmsData.getIpMulticastMedia(), mbmsData.getPortMulticastMedia(), mbmsData.getPortControlMulticastMedia())) {
                         if(mbmsExternalServiceListener!=null)mbmsExternalServiceListener.startMbmsMedia(session.getId(),tmgi);

                         if (BuildConfig.DEBUG)

                             Log.i(TAG, "execute ok mbms listeningMulticast in session id:" + session.getId());

                     } else {
                         if (BuildConfig.DEBUG)

                             Log.e(TAG, "No correct execute mbms listeningMulticast in session id:" + session.getId());

                     }
                 }
 

         }else{
             //TODO: Is no Tried;
             NgnObservableHashMap<Long, NgnAVSession> sessions = NgnAVSession.getSessions();
             if(sessions!=null && !sessions.isEmpty())
                 for(NgnAVSession session:sessions.values()) {
                     if (session.isActive() && session.isConnected() && session.stopMbmsManager()) {
                         if(mbmsExternalServiceListener!=null)mbmsExternalServiceListener.stopMbmsMedia(session.getId(),tmgi);
                         if (BuildConfig.DEBUG)
                             Log.i(TAG, "execute ok stopMbmsManager in session id:" + session.getId());
                     } else {
                         if (BuildConfig.DEBUG)
                             Log.e(TAG, "No correct execute stopMbmsManager in session id:" + session.getId());
                     }
                 }

         }
         return ret;
     }
 
 

     public void hangUpCallMbms(long sessionID){
 
         NgnObservableHashMap<Long, NgnAVSession> sessions = NgnAVSession.getSessions();
         NgnAVSession session=NgnAVSession.getSession(sessionID);
         long tmgi=-1;
         MbmsData mbmsData=null;
         if(mbmsData!=null){
             String groupID=session.getPTTMcpttGroupIdentity();
             mbmsData=getMbmsDataOfTmgi(groupID);
             if(mbmsData==null || (tmgi=mbmsData.getMcpttMbmsUsageInfoType().getAnnouncement().getTMGIBigInteger().longValue())<0){
                 if(BuildConfig.DEBUG){
                     Log.w(TAG,"TMGI not found for session "+sessionID);
                 }
             }
         }
 
         Log.d(TAG,"hangUpCallMbms MBMS");
         if(mbmsExternalServiceListener!=null)
             mbmsExternalServiceListener.stopMbmsMedia(sessionID,tmgi);
     }
 
 
 

     public void stopServiceMbms(){
         Log.d(TAG,"Stop MBMS server.");
         mbmsExtensionService.setSessionIdCurrent(null);
         mbmsExtensionService.deleteActiveMcpttMbmsUsageInfoTypeforTMGI();
         mbmsExtensionService.deleteActiveMcpttMbmsUsageInfoType();
         if(mbmsExternalServiceListener!=null)
             mbmsExternalServiceListener.stopServiceMBMS();
     }
 
 
     public void setOnMbmsListener(OnMbmsListener onMbmsListener){
         this.onMbmsListener=onMbmsListener;
     }
     public Iterator<Integer> getServiceAreas(){
         Iterator<Integer> serviceAreas=null;
         if(mbmsExtensionService!=null && !mbmsExtensionService.getActiveMcpttMbmsUsageInfoType().isEmpty()){
             Set<Integer> stringSet=mbmsExtensionService.getActiveMcpttMbmsUsageInfoType().keySet();
             serviceAreas=stringSet.iterator();
         }
         return serviceAreas;
     }
 
 
 
 
             private void startClient(Context context) throws PackageManager.NameNotFoundException, MalformedURLException {
         if(BuildConfig.DEBUG)Log.d(TAG,"Starting CLIENT MBMS.");
         mbmsExtensionService.startClient(context);
     }
 
     private void stopClient(Context context) throws PackageManager.NameNotFoundException, MalformedURLException {
         if(BuildConfig.DEBUG)Log.d(TAG,"Stoping CLIENT MBMS.");
         mbmsExtensionService.stopClient(context);
     }
 
     private void stopServer(Context context) throws PackageManager.NameNotFoundException, MalformedURLException {
         Log.d(TAG,"Stoping SERVER MBMS.");
         mbmsExtensionService.stopServer(context);
     }
 
 
     private void startServer(Context context) throws PackageManager.NameNotFoundException, MalformedURLException {
         Log.d(TAG,"Starting SERVER MBMS.");
         mbmsExtensionService.startServer(context);
     }
 
 
     @Override
     public boolean clearService(){
         return true;
     }
 
 
     //INIT EXTERNAL MBMS
 
     public void setMbmsExternalServiceListener(MbmsExternalServiceListener mbmsExternalServiceListener){
         this.mbmsExternalServiceListener=mbmsExternalServiceListener;
     }
     //END EXTERNAL MBMS
 
 }