ImsConference.java中会议成员更新处理详解

public class ConferenceParticipant implements Parcelable {  //自定义数据结构

　　private static final String ANONYMOUS_INVALID_HOST

　　private final Uri mHandle;

  　private final String mDisplayName;

　　private final Uri mEndpoint;

　　private final int mState;

  　private long mConnectTime;

 　 private long mConnectElapsedTime;

　　private int mCallDirection;}

public class DisconnectCause implements Parcelable { ...}

participant: ConferenceParticipantConnection.java

   public void handleConferenceParticipantsUpdate(
          TelephonyConnection parent, List<ConferenceParticipant> participants) {

　　　　　　//不支持会议管理，return
          if (parent != null && !parent.isManageImsConferenceCallSupported()) {
            Log.i(this, "handleConferenceParticipantsUpdate: manage conference is disallowed");
         　　 return;
          }
          Log.i(this, "handleConferenceParticipantsUpdate: size=%d", participants.size());

         // 以同步方式执行更新。IMS framework可以快速连续地触发两次onConferenceParticipantsChanged callbacks。         //  第一次更新添加新的参与者，第二次更新其中一个参与者的状态。
         synchronized (mUpdateSyncRoot) {   //private final Object
            int oldParticipantCount = mConferenceParticipantConnections.size();
            boolean newParticipantsAdded = false;
            boolean oldParticipantsRemoved = false;
            ArrayList<ConferenceParticipant> newParticipants = new ArrayList<>(participants.size());
            HashSet<Pair<Uri,Uri>> participantUserEntities   = new HashSet<>(participants.size());

            // Determine if the conference event package represents a single party conference.
            // A single party conference ：除了host外，只有1个会议成员.         // Note: We consider 0 to still be a single party conference since some carriers will
          // send a conference event package with JUST the host in it when the conference is
         // disconnected.  We don't want to change back to conference mode prior to disconnection
         // or we will not log the call.
         boolean isSinglePartyConference = participants.stream()  //1.后面在解析
                   .filter(p -> {
                    Pair<Uri, Uri> pIdent = new Pair<>(p.getHandle(), p.getEndpoint());
                       return !Objects.equals(mHostParticipantIdentity, pIdent);
                }).count() <= 1;

        if ((mIsEmulatingSinglePartyCall && !isSinglePartyConference) ||
               !mIsEmulatingSinglePartyCall) {
             // Add any new participants and update existing.
         　　for (ConferenceParticipant participant : participants) {
              　　Pair<Uri, Uri> userEntity = new Pair<>(participant.getHandle(),participant.getEndpoint());
                     　　participantUserEntities.add(userEntity);
　　　　　　　　　　　　　 if (!mConferenceParticipantConnections.containsKey(userEntity)) { //不存在 userEntity
                       　　// Some carriers will also include the conference host in the CEP.  We will filter that out here.
　　　　　　　　　　　　　　　　if (!isParticipantHost(mConferenceHostAddress, participant.getHandle())) {
  　　　　　　　　　　　　　　　　　　createConferenceParticipantConnection(parent, participant);
                               newParticipants.add(participant);
                               newParticipantsAdded = true;
                         } else {
                             // Track the identity of the conference host; its useful to know when
                             // we look at the CEP in the future.
                             mHostParticipantIdentity = userEntity;
                         }
                      } else { //存在 userEntity
                   　　　　ConferenceParticipantConnection connection = mConferenceParticipantConnections.get(userEntity);
                   　　　　Log.i(this,"handleConferenceParticipantsUpdate: updateState, participant = %s",participant);
　　　　　　　　　　　　　　　　connection.updateState(participant.getState());
　　　　　　　　　　　　　　　　connection.setVideoState(parent.getVideoState());
　　　　　　　　　　　　 }
                }

                 // Set state of new participants.
                  if (newParticipantsAdded) {
                    // Set the state of the new participants at once and add to the conference
                    for (ConferenceParticipant newParticipant : newParticipants) {
                         ConferenceParticipantConnection connection =
                       mConferenceParticipantConnections.get(new Pair<>(
                                          newParticipant.getHandle(),newParticipant.getEndpoint()));
                         connection.updateState(newParticipant.getState());
                         connection.setVideoState(parent.getVideoState());
                     }
                  }

　　　　　　　　//最后，从会议中删除不再存在于会议事件包数据中的任何参与者。
                 Iterator<Map.Entry<Pair<Uri, Uri>, ConferenceParticipantConnection>> entryIterator =
                          mConferenceParticipantConnections.entrySet().iterator();
                 while (entryIterator.hasNext()) {
                      Map.Entry<Pair<Uri, Uri>, ConferenceParticipantConnection> entry = entryIterator.next();

                      if (!participantUserEntities.contains(entry.getKey())) {
                          ConferenceParticipantConnection participant = entry.getValue();
                          participant.setDisconnected(new DisconnectCause(DisconnectCause.CANCELED));
                          participant.removeConnectionListener(mParticipantListener);
                          mTelephonyConnectionService.removeConnection(participant);
                          removeConnection(participant);
                          entryIterator.remove();
                          oldParticipantsRemoved = true;
                      }
                 }
             }

             int newParticipantCount = mConferenceParticipantConnections.size();
             Log.v(this, "handleConferenceParticipantsUpdate: oldParticipantCount=%d, "
                              + "newParticipantcount=%d", oldParticipantCount, newParticipantCount);
             // If the single party call emulation fature flag is enabled, we can potentially treat
             // the conference as a single party call when there is just one participant.
             if (mFeatureFlagProxy.isUsingSinglePartyCallEmulation()) {
                  if (oldParticipantCount > 1 && newParticipantCount == 1) {
                     // If number of participants goes to 1, emulate a single party call.
                     startEmulatingSinglePartyCall();
                 } else if (mIsEmulatingSinglePartyCall && !isSinglePartyConference) {
                     // Number of participants increased, so stop emulating a single party call.
                     stopEmulatingSinglePartyCall();
                 }
            }
             // If new participants were added or old ones were removed, we need to ensure the state
             // of the manage conference capability is updated.
             if (newParticipantsAdded || oldParticipantsRemoved) {
                 updateManageConference();
             }
          }
     }

handleConferenceParticipantsUpdate:　　1.ImsConferenceCallSupported判断　　2.isSinglePartyConference判断　　3.不EmulatingSinglePartyCall或EmulatingSinglePartyCall且SinglePartyConference条件下，添加成员，更新成员信息　　4.新成员被添加到ConferenceParticipant中，更新信息　　5.remove，从会议中删除不再存在于会议事件包数据中的任何参与者　　6.startEmulatingSinglePartyCall()或stopEmulatingSinglePartyCall()　　7.新成员增加或就成员remove， updateManageConference()

 /**
      a single party call：会议电话成员只有1名与会者。      * 1. Set the name/address to that of the single participant.
      * 2. Remove the participant from Telecom and from local tracking; when we get a new CEP in
      *    the future we'll just re-add the participant anyways.
      * 3. Tell telecom we're not a conference.
      * 4. Remove {@link Connection#CAPABILITY_MANAGE_CONFERENCE} capability.

     *注意:如果会议是通过sim call manager进行的，单方呼叫模拟将被禁用。模拟单方呼叫需要更改会议的属性(连接时间、地址、会议状态)，       sim call manager 不能保证将这些属性正确地转发到Telecom。
      */
      private void startEmulatingSinglePartyCall() {
          if (mIsUsingSimCallManager) {
             Log.i(this, "startEmulatingSinglePartyCall: using sim call manager; skip.");
            return;
          }

          Log.i(this, "startEmulatingSinglePartyCall: conference has a single "
                  + "participant; downgrade to single party call.");

         mIsEmulatingSinglePartyCall = true;
         Iterator<ConferenceParticipantConnection> valueIterator =
                 mConferenceParticipantConnections.values().iterator();
         if (valueIterator.hasNext()) {
             ConferenceParticipantConnection entry = valueIterator.next();

             // Set the conference name/number to that of the remaining participant.
            setAddress(entry.getAddress(), entry.getAddressPresentation());
            setCallerDisplayName(entry.getCallerDisplayName(),entry.getCallerDisplayNamePresentation());
            setConnectionStartElapsedRealTime(entry.getConnectElapsedTimeMillis());
            setConnectionTime(entry.getConnectTimeMillis());
            mLoneParticipantIdentity = new Pair<>(entry.getUserEntity(), entry.getEndpoint());

             // Remove the participant from Telecom.  It'll get picked up in a future CEP update again anyways.
            entry.setDisconnected(new DisconnectCause(DisconnectCause.CANCELED,DisconnectCause.REASON_EMULATING_SINGLE_CALL));
            entry.removeConnectionListener(mParticipantListener);
            mTelephonyConnectionService.removeConnection(entry);
            removeConnection(entry);
            valueIterator.remove();

           // Have Telecom pretend its not a conference.
           setConferenceState(false);

           //Remove manage conference capability.
           mCouldManageConference = can(Connection.CAPABILITY_MANAGE_CONFERENCE);
           int currentCapabilities = getConnectionCapabilities();
           currentCapabilities &= ~Connection.CAPABILITY_MANAGE_CONFERENCE;
           setConnectionCapabilities(currentCapabilities);
      }