/**
 * Process the MultiMedia Session invitation<br>
 * Purpose is to retrieve the contactId from the service to build the notification.
 *
 * @author YPLO6403
 */
public class MultiMediaSessionIntentService extends IntentService {

  private String mSessionId;

  private boolean mMultimediaMessagingSession = false;

  private ConnectionManager mCnxManager;

  private static final String LOGTAG =
      LogUtils.getTag(MultiMediaSessionIntentService.class.getSimpleName());

  /** Constructor */
  public MultiMediaSessionIntentService() {
    super("MultiMediaSessionIntentService");
  }

  @Override
  public int onStartCommand(Intent intent, int flags, int startId) {
    super.onStartCommand(intent, flags, startId);
    /*
     * We want this service to stop running if forced stop so return not sticky.
     */
    return START_NOT_STICKY;
  }

  @Override
  protected void onHandleIntent(Intent intent) {
    String action;
    if ((action = intent.getAction()) == null) {
      return;
    }

    if (MultimediaMessagingSessionIntent.ACTION_NEW_INVITATION.equals(action)) {
      mMultimediaMessagingSession = true;
    } else {
      if (!MultimediaStreamingSessionIntent.ACTION_NEW_INVITATION.equals(action)) {
        if (LogUtils.isActive) {
          Log.d(LOGTAG, "Unknown action=".concat(action));
        }
        return;
      }
    }
    /* Since there is no provider associated to multimedia sessions, we must connect to the API */
    mCnxManager = ConnectionManager.getInstance();
    if (!mCnxManager.isServiceConnected(RcsServiceName.MULTIMEDIA)) {
      return;
    }
    // Get invitation info
    mSessionId = intent.getStringExtra(MultimediaMessagingSessionIntent.EXTRA_SESSION_ID);
    if (LogUtils.isActive) {
      Log.d(LOGTAG, "onHandleIntent sessionId=".concat(mSessionId));
    }
    initiateSession(intent);
  }

  private void initiateSession(Intent intent) {
    try {
      if (mMultimediaMessagingSession) {
        MultimediaMessagingSession mms =
            mCnxManager.getMultimediaSessionApi().getMessagingSession(mSessionId);
        if (mms != null) {
          addSessionInvitationNotification(intent, mms.getRemoteContact());
        } else {
          if (LogUtils.isActive) {
            Log.w(LOGTAG, "Cannot get messaging session for ID ".concat(mSessionId));
          }
        }
      } else {
        MultimediaStreamingSession mss =
            mCnxManager.getMultimediaSessionApi().getStreamingSession(mSessionId);
        if (mss != null) {
          addSessionInvitationNotification(intent, mss.getRemoteContact());
        } else {
          if (LogUtils.isActive) {
            Log.w(LOGTAG, "Cannot get streaming session for ID ".concat(mSessionId));
          }
        }
      }
    } catch (RcsServiceException e) {
      if (LogUtils.isActive) {
        Log.e(LOGTAG, "Cannot get MM API", e);
      }
    }
  }

  private void addSessionInvitationNotification(Intent intent, ContactId contact) {
    /* Create pending intent */
    Intent invitation = new Intent(intent);
    String title;
    if (mMultimediaMessagingSession) {
      invitation.setClass(this, MessagingSessionView.class);
      title = getString(R.string.title_recv_messaging_session);
    } else {
      invitation.setClass(this, StreamingSessionView.class);
      title = getString(R.string.title_recv_streaming_session);
    }
    invitation.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
    /*
     * If the PendingIntent has the same operation, action, data, categories, components, and
     * flags it will be replaced. Invitation should be notified individually so we use a random
     * generator to provide a unique request code and reuse it for the notification.
     */
    int uniqueId = Utils.getUniqueIdForPendingIntent();
    PendingIntent contentIntent =
        PendingIntent.getActivity(this, uniqueId, invitation, PendingIntent.FLAG_ONE_SHOT);

    String displayName = RcsContactUtil.getInstance(this).getDisplayName(contact);

    /* Create notification */
    NotificationCompat.Builder notif = new NotificationCompat.Builder(this);
    notif.setContentIntent(contentIntent);
    notif.setSmallIcon(R.drawable.ri_notif_mm_session_icon);
    notif.setWhen(System.currentTimeMillis());
    notif.setAutoCancel(true);
    notif.setOnlyAlertOnce(true);
    notif.setSound(RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION));
    notif.setDefaults(Notification.DEFAULT_VIBRATE);
    notif.setContentTitle(title);
    notif.setContentText(getString(R.string.label_from_args, displayName));

    /* Send notification */
    NotificationManager notificationManager =
        (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
    notificationManager.notify(uniqueId, notif.build());
  }
}
Example #2
0
/**
 * CHAT API
 *
 * @author Jean-Marc AUFFRET
 */
public class TestChatApi extends ListActivity {

  private static final String[] PROJECTION = new String[] {CapabilitiesLog.CONTACT};

  private static final String LOGTAG = LogUtils.getTag(TestChatApi.class.getSimpleName());

  @Override
  public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    // Set layout
    setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
    // @formatter:off
    String[] items = {
      getString(R.string.menu_initiate_chat),
      getString(R.string.menu_chat_log),
      getString(R.string.menu_initiate_group_chat),
      getString(R.string.menu_group_chat_log),
      getString(R.string.menu_chat_service_config),
      getString(R.string.menu_showus_map),
    };
    // @formatter:on
    setListAdapter(new ArrayAdapter<String>(this, android.R.layout.simple_list_item_1, items));
  }

  @Override
  protected void onListItemClick(ListView l, View v, int position, long id) {
    switch (position) {
      case 0:
        startActivity(new Intent(this, InitiateSingleChat.class));
        break;

      case 1:
        startActivity(new Intent(this, SingleChatList.class));
        break;

      case 2:
        /* Check if Group chat initialization is allowed */
        ChatService chatService = ConnectionManager.getInstance().getChatApi();
        try {
          if (chatService.isAllowedToInitiateGroupChat()) {
            startActivity(new Intent(this, InitiateGroupChat.class));
          } else {
            Utils.showMessage(this, getString(R.string.label_NotAllowedToInitiateGroupChat));
          }
        } catch (RcsServiceException e) {
          if (LogUtils.isActive) {
            Log.d(LOGTAG, "Cannot check if Group chat initialization is allowed", e);
          }
          Utils.showMessage(this, getString(R.string.label_api_failed));
        }
        break;

      case 3:
        startActivity(new Intent(this, GroupChatList.class));
        break;

      case 4:
        startActivity(new Intent(this, ChatServiceConfigActivity.class));
        break;

      case 5:
        Set<ContactId> contacts = new HashSet<ContactId>();
        Cursor cursor = null;
        try {
          cursor =
              getContentResolver().query(CapabilitiesLog.CONTENT_URI, PROJECTION, null, null, null);
          while (cursor.moveToNext()) {
            String contact = cursor.getString(cursor.getColumnIndex(CapabilitiesLog.CONTACT));
            contacts.add(ContactUtil.formatContact(contact));
          }
          DisplayGeoloc.showContactsOnMap(this, contacts);
        } catch (Exception e) {
          // Skip intentionally
        } finally {
          if (cursor != null) {
            cursor.close();
          }
        }
        break;
    }
  }
}
Example #3
0
/**
 * Initiate file transfer
 *
 * @author Jean-Marc AUFFRET
 * @author Philippe LEMORDANT
 */
public class InitiateFileTransfer extends RcsActivity {

  private static final int SELECT_IMAGE = 0;

  private static final int SELECT_TEXT_FILE = 1;

  private static final String BUNDLE_FTDAO_ID = "ftdao";

  /** UI handler */
  private final Handler mHandler = new Handler();

  private String mFilename;

  private Uri mFile;

  private long mFilesize = -1;

  private FileTransfer mFileTransfer;

  private Dialog mProgressDialog;

  private static final String LOGTAG = LogUtils.getTag(InitiateFileTransfer.class.getSimpleName());

  private String mFileTransferId;

  /** Spinner for contact selection */
  private Spinner mSpinner;

  private Button mResumeBtn;

  private Button mPauseBtn;

  private Button mInviteBtn;

  private Button mSelectBtn;

  private OneToOneFileTransferListener mFileTransferListener;

  private OnClickListener mBtnInviteListener;

  private OnClickListener mBtnSelectListener;

  private OnClickListener mBtnPauseListener;

  private OnClickListener mBtnResumeListener;

  private FileTransferService mFileTransferService;

  @Override
  public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    intitialize();
    ContactId remoteContact;
    Intent intent = getIntent();
    boolean resuming = FileTransferIntent.ACTION_RESUME.equals(intent.getAction());

    setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
    setContentView(R.layout.filetransfer_initiate);

    /* Set contact selector */
    mSpinner = (Spinner) findViewById(R.id.contact);

    /* Set buttons callback */
    mInviteBtn = (Button) findViewById(R.id.invite_btn);
    mInviteBtn.setOnClickListener(mBtnInviteListener);
    mInviteBtn.setEnabled(false);
    mSelectBtn = (Button) findViewById(R.id.select_btn);
    mSelectBtn.setOnClickListener(mBtnSelectListener);
    mSelectBtn.setEnabled(false);

    mPauseBtn = (Button) findViewById(R.id.pause_btn);
    mPauseBtn.setOnClickListener(mBtnPauseListener);
    mPauseBtn.setEnabled(false);

    mResumeBtn = (Button) findViewById(R.id.resume_btn);
    mResumeBtn.setOnClickListener(mBtnResumeListener);
    mResumeBtn.setEnabled(false);

    TableRow expiration = (TableRow) findViewById(R.id.expiration);
    expiration.setVisibility(View.GONE);

    if (!isServiceConnected(RcsServiceName.FILE_TRANSFER)) {
      showMessageThenExit(R.string.label_service_not_available);
      return;
    }
    startMonitorServices(RcsServiceName.FILE_TRANSFER);
    mFileTransferService = getFileTransferApi();
    try {
      mFileTransferService.addEventListener(mFileTransferListener);
      if (resuming) {
        /* Get resuming info */
        FileTransferDAO ftdao =
            (FileTransferDAO) (intent.getExtras().getSerializable(BUNDLE_FTDAO_ID));
        if (ftdao == null) {
          if (LogUtils.isActive) {
            Log.e(LOGTAG, "onCreate cannot read File Transfer resuming info");
          }
          finish();
          return;
        }
        remoteContact = ftdao.getContact();
        mFileTransferId = ftdao.getTransferId();
        mFilename = ftdao.getFilename();
        mFilesize = ftdao.getSize();
        ArrayAdapter<String> adapter =
            new ArrayAdapter<>(
                this,
                android.R.layout.simple_spinner_item,
                new String[] {remoteContact.toString()});
        mSpinner.setAdapter(adapter);
        TextView uriEdit = (TextView) findViewById(R.id.uri);
        TextView sizeEdit = (TextView) findViewById(R.id.size);
        sizeEdit.setText((mFilesize / 1024) + " KB");
        uriEdit.setText(mFilename);
        /* Check if session still exists */
        if (mFileTransferService.getFileTransfer(mFileTransferId) == null) {
          /* Session not found or expired */
          showMessageThenExit(R.string.label_transfer_session_has_expired);
          return;
        }
        if (LogUtils.isActive) {
          Log.d(
              LOGTAG,
              "onCreate (file="
                  + mFilename
                  + ") (size="
                  + mFilesize
                  + ") (contact="
                  + remoteContact
                  + ")");
        }
      } else {
        mSpinner.setAdapter(ContactListAdapter.createRcsContactListAdapter(this));
        /* Enable button if contact available */
        if (mSpinner.getAdapter().getCount() != 0) {
          mSelectBtn.setEnabled(true);
        }
        if (LogUtils.isActive) {
          Log.d(LOGTAG, "onCreate");
        }
      }

    } catch (RcsServiceException e) {
      showExceptionThenExit(e);
    }
  }

  @Override
  public void onDestroy() {
    if (LogUtils.isActive) {
      Log.d(LOGTAG, "onDestroy");
    }
    super.onDestroy();
    if (mFileTransferService != null && isServiceConnected(RcsServiceName.FILE_TRANSFER)) {
      // Remove file transfer listener
      try {
        mFileTransferService.removeEventListener(mFileTransferListener);
      } catch (RcsServiceException e) {
        Log.w(LOGTAG, ExceptionUtil.getFullStackTrace(e));
      }
    }
  }

  private void initiateTransfer(ContactId remote) {
    /* Get thumbnail option */
    CheckBox ftThumb = (CheckBox) findViewById(R.id.ft_thumb);
    boolean tryToSendFileicon = ftThumb.isChecked();
    String mimeType = getContentResolver().getType(mFile);
    if (tryToSendFileicon && mimeType != null && !mimeType.startsWith("image")) {
      tryToSendFileicon = false;
    }
    try {
      /* Only take persistable permission for content Uris */
      takePersistableContentUriPermission(this, mFile);
      /* Initiate transfer */
      mFileTransfer = mFileTransferService.transferFile(remote, mFile, tryToSendFileicon);
      mFileTransferId = mFileTransfer.getTransferId();
      mProgressDialog = showProgressDialog(getString(R.string.label_command_in_progress));
      mProgressDialog.setOnCancelListener(
          new OnCancelListener() {
            public void onCancel(DialogInterface dialog) {
              Toast.makeText(
                      InitiateFileTransfer.this,
                      getString(R.string.label_transfer_cancelled),
                      Toast.LENGTH_SHORT)
                  .show();
              quitSession();
            }
          });
      /* Disable UI */
      mSpinner.setEnabled(false);
      /* Hide buttons */
      mInviteBtn.setVisibility(View.INVISIBLE);
      mSelectBtn.setVisibility(View.INVISIBLE);
      ftThumb.setVisibility(View.INVISIBLE);

    } catch (RcsServiceException e) {
      showExceptionThenExit(e);
    }
  }

  /** Display a alert dialog to select the kind of file to transfer */
  private void selectDocument() {
    AlertDialog.Builder builder = new AlertDialog.Builder(this);
    builder.setTitle(R.string.label_select_file);
    builder.setCancelable(true);
    builder.setItems(
        R.array.select_filetotransfer,
        new DialogInterface.OnClickListener() {

          @Override
          public void onClick(DialogInterface dialog, int which) {
            if (which == SELECT_IMAGE) {
              FileUtils.openFile(InitiateFileTransfer.this, "image/*", SELECT_IMAGE);
            } else {
              FileUtils.openFile(InitiateFileTransfer.this, "text/plain", SELECT_TEXT_FILE);
            }
          }
        });
    registerDialog(builder.show());
  }

  @Override
  public void onActivityResult(int requestCode, int resultCode, Intent data) {
    if (resultCode != RESULT_OK || (data == null) || (data.getData() == null)) {
      return;
    }
    mFile = data.getData();
    TextView uriEdit = (TextView) findViewById(R.id.uri);
    TextView sizeEdit = (TextView) findViewById(R.id.size);
    switch (requestCode) {
      case SELECT_IMAGE:
      case SELECT_TEXT_FILE:
        if (LogUtils.isActive) {
          Log.d(LOGTAG, "Selected file uri:" + mFile);
        }
        /*
         * Display file info and the selected filename attribute.
         */
        mFilename = FileUtils.getFileName(this, mFile);
        mFilesize = FileUtils.getFileSize(this, mFile) / 1024;
        sizeEdit.setText(mFilesize + " KB");
        uriEdit.setText(mFilename);
        if (LogUtils.isActive) {
          Log.i(LOGTAG, "Select file " + mFilename + " of size " + mFilesize + " file=" + mFile);
        }
        mInviteBtn.setEnabled(true);
        break;
    }
  }

  private void hideProgressDialog() {
    if (mProgressDialog != null && mProgressDialog.isShowing()) {
      mProgressDialog.dismiss();
      mProgressDialog = null;
    }
  }

  private void updateProgressBar(long currentSize, long totalSize) {
    TextView statusView = (TextView) findViewById(R.id.progress_status);
    ProgressBar progressBar = (ProgressBar) findViewById(R.id.progress_bar);
    statusView.setText(Utils.getProgressLabel(currentSize, totalSize));
    double position = ((double) currentSize / (double) totalSize) * 100.0;
    progressBar.setProgress((int) position);
  }

  private void quitSession() {
    if (LogUtils.isActive) {
      Log.d(LOGTAG, "quitSession");
    }
    try {
      if (mFileTransfer != null
          && RcsSessionUtil.isAllowedToAbortFileTransferSession(mFileTransfer)) {
        mFileTransfer.abortTransfer();
      }
    } catch (RcsServiceException e) {
      showException(e);

    } finally {
      mFileTransfer = null;
      finish();
    }
  }

  @Override
  public boolean onKeyDown(int keyCode, KeyEvent event) {
    try {
      if (KeyEvent.KEYCODE_BACK == keyCode) {
        if (mFileTransfer == null
            || !RcsSessionUtil.isAllowedToAbortFileTransferSession(mFileTransfer)) {
          finish();
          return true;
        }
        AlertDialog.Builder builder = new AlertDialog.Builder(this);
        builder.setTitle(R.string.label_confirm_close);
        builder.setPositiveButton(
            R.string.label_ok,
            new DialogInterface.OnClickListener() {
              public void onClick(DialogInterface dialog, int which) {
                quitSession();
              }
            });
        builder.setNegativeButton(
            R.string.label_cancel,
            new DialogInterface.OnClickListener() {
              public void onClick(DialogInterface dialog, int which) {
                /* Exit activity */
                finish();
              }
            });
        builder.setCancelable(true);
        registerDialog(builder.show());
        return true;
      }
    } catch (RcsServiceException e) {
      showException(e);
    }
    return super.onKeyDown(keyCode, event);
  }

  @Override
  public boolean onCreateOptionsMenu(Menu menu) {
    MenuInflater inflater = new MenuInflater(getApplicationContext());
    inflater.inflate(R.menu.menu_ft, menu);
    return true;
  }

  @Override
  public boolean onOptionsItemSelected(MenuItem item) {
    switch (item.getItemId()) {
      case R.id.menu_close_session:
        quitSession();
        break;
    }
    return true;
  }

  private void displayFileExpiration(long fileExpiration) {
    if (FileTransferLog.UNKNOWN_EXPIRATION == fileExpiration) {
      return;
    }
    TableRow expirationTableRow = (TableRow) findViewById(R.id.expiration);
    expirationTableRow.setVisibility(View.VISIBLE);
    TextView expirationView = (TextView) findViewById(R.id.value_expiration);
    CharSequence expirationDate =
        DateUtils.getRelativeTimeSpanString(
            fileExpiration,
            System.currentTimeMillis(),
            DateUtils.MINUTE_IN_MILLIS,
            DateUtils.FORMAT_ABBREV_RELATIVE);
    expirationView.setText(expirationDate);
  }

  private void intitialize() {
    mFileTransferListener =
        new OneToOneFileTransferListener() {

          @Override
          public void onProgressUpdate(
              ContactId contact, String transferId, final long currentSize, final long totalSize) {
            /* Discard event if not for current transferId */
            if (InitiateFileTransfer.this.mFileTransferId == null
                || !InitiateFileTransfer.this.mFileTransferId.equals(transferId)) {
              return;
            }
            mHandler.post(
                new Runnable() {
                  public void run() {
                    updateProgressBar(currentSize, totalSize);
                  }
                });
          }

          @Override
          public void onStateChanged(
              ContactId contact,
              String transferId,
              final FileTransfer.State state,
              final FileTransfer.ReasonCode reasonCode) {
            /* Discard event if not for current transferId */
            if (InitiateFileTransfer.this.mFileTransferId == null
                || !InitiateFileTransfer.this.mFileTransferId.equals(transferId)) {
              return;
            }
            final String _reasonCode = RiApplication.sFileTransferReasonCodes[reasonCode.toInt()];
            final String _state = RiApplication.sFileTransferStates[state.toInt()];
            if (LogUtils.isActive) {
              Log.d(
                  LOGTAG,
                  "onStateChanged contact="
                      + contact
                      + " transferId="
                      + transferId
                      + " state="
                      + _state
                      + " reason="
                      + _reasonCode);
            }
            mHandler.post(
                new Runnable() {

                  public void run() {
                    if (mFileTransfer != null) {
                      try {
                        mResumeBtn.setEnabled(mFileTransfer.isAllowedToResumeTransfer());

                      } catch (RcsServiceException e) {
                        mResumeBtn.setEnabled(false);
                        showException(e);
                      }
                      try {
                        mPauseBtn.setEnabled(mFileTransfer.isAllowedToPauseTransfer());

                      } catch (RcsServiceException e) {
                        mPauseBtn.setEnabled(false);
                        showException(e);
                      }
                    }
                    TextView statusView = (TextView) findViewById(R.id.progress_status);
                    switch (state) {
                      case STARTED:
                        /* Session is well established : hide progress dialog */
                        hideProgressDialog();
                        /* Display session status */
                        statusView.setText(_state);
                        break;

                      case ABORTED:
                        showMessageThenExit(
                            getString(R.string.label_transfer_aborted, _reasonCode));
                        break;

                      case REJECTED:
                        showMessageThenExit(
                            getString(R.string.label_transfer_rejected, _reasonCode));
                        break;

                      case FAILED:
                        showMessageThenExit(getString(R.string.label_transfer_failed, _reasonCode));
                        break;

                      case TRANSFERRED:
                        hideProgressDialog(); // TODO check if required
                        /* Display transfer progress */
                        statusView.setText(_state);

                        try {
                          displayFileExpiration(mFileTransfer.getFileExpiration());
                          Uri fileIconUri = mFileTransfer.getFileIcon();
                          long fileIconExpiration = mFileTransfer.getFileIconExpiration();
                          if (LogUtils.isActive) {
                            Log.d(
                                LOGTAG,
                                "File transferred icon uri= "
                                    + fileIconUri
                                    + " expiration="
                                    + fileIconExpiration);
                          }
                        } catch (RcsServiceException e) {
                          showException(e);
                        }
                        break;

                      default:
                        statusView.setText(_state);
                        if (LogUtils.isActive) {
                          Log.d(
                              LOGTAG,
                              "onStateChanged "
                                  .concat(
                                      getString(
                                          R.string.label_ft_state_changed, _state, _reasonCode)));
                        }
                    }
                  }
                });
          }

          @Override
          public void onDeleted(ContactId contact, Set<String> transferIds) {
            if (LogUtils.isActive) {
              Log.w(LOGTAG, "onDeleted contact=" + contact + " transferIds=" + transferIds);
            }
          }
        };

    mBtnInviteListener =
        new OnClickListener() {
          public void onClick(View v) {
            ContactListAdapter adapter = (ContactListAdapter) mSpinner.getAdapter();
            String phoneNumber = adapter.getSelectedNumber(mSpinner.getSelectedView());
            final ContactId remote = ContactUtil.formatContact(phoneNumber);

            long warnSize;
            try {
              warnSize = mFileTransferService.getConfiguration().getWarnSize();

            } catch (RcsServiceException e) {
              showExceptionThenExit(e);
              return;
            }
            if ((warnSize > 0) && (mFilesize >= warnSize)) {
              // Display a warning message
              AlertDialog.Builder builder = new AlertDialog.Builder(InitiateFileTransfer.this);
              builder.setMessage(getString(R.string.label_sharing_warn_size, mFilesize));
              builder.setCancelable(false);
              builder.setPositiveButton(
                  R.string.label_yes,
                  new DialogInterface.OnClickListener() {
                    public void onClick(DialogInterface dialog, int position) {
                      initiateTransfer(remote);
                    }
                  });
              builder.setNegativeButton(R.string.label_no, null);
              registerDialog(builder.show());

            } else {
              initiateTransfer(remote);
            }
          }
        };

    mBtnSelectListener =
        new OnClickListener() {
          public void onClick(View v) {
            selectDocument();
          }
        };

    mBtnPauseListener =
        new OnClickListener() {
          public void onClick(View v) {
            try {
              if (mFileTransfer.isAllowedToPauseTransfer()) {
                mFileTransfer.pauseTransfer();
              } else {
                mPauseBtn.setEnabled(false);
                showMessage(R.string.label_pause_ft_not_allowed);
              }
            } catch (RcsServiceException e) {
              showExceptionThenExit(e);
            }
          }
        };

    mBtnResumeListener =
        new OnClickListener() {
          public void onClick(View v) {
            try {
              if (mFileTransfer.isAllowedToResumeTransfer()) {
                mFileTransfer.resumeTransfer();

              } else {
                mResumeBtn.setEnabled(false);
                showMessage(R.string.label_resume_ft_not_allowed);
              }
            } catch (RcsServiceException e) {
              showExceptionThenExit(e);
            }
          }
        };
  }

  /**
   * Forge intent to resume Originating File Transfer
   *
   * @param ctx The context
   * @param ftDao The FileTransfer DAO
   * @param resume intent
   * @return intent
   */
  public static Intent forgeResumeIntent(Context ctx, FileTransferDAO ftDao, Intent resume) {
    resume.setClass(ctx, InitiateFileTransfer.class);
    resume.addFlags(Intent.FLAG_FROM_BACKGROUND | Intent.FLAG_ACTIVITY_NEW_TASK);
    /* Save FileTransferDAO into intent */
    Bundle bundle = new Bundle();
    bundle.putParcelable(BUNDLE_FTDAO_ID, ftDao);
    resume.putExtras(bundle);
    return resume;
  }
}
Example #4
0
/** Group chat view */
public class GroupChatView extends ChatView {
  /** Intent parameters */
  private static final String EXTRA_PARTICIPANTS = "participants";

  private static final String EXTRA_SUBJECT = "subject";

  private static final String EXTRA_MODE = "mode";

  private enum GroupChatMode {
    INCOMING,
    OUTGOING,
    OPEN
  }

  /** List of items for contextual menu */
  private static final int GROUPCHAT_MENU_ITEM_DELETE = 0;

  private static final int GROUPCHAT_MENU_ITEM_VIEW_GC_INFO = 1;

  private static final String WHERE_CLAUSE = HistoryLog.CHAT_ID + "=?";

  private String mSubject;

  private String mChatId;

  private GroupChat mGroupChat;

  private Dialog mProgressDialog;

  private Set<ContactId> mParticipants = new HashSet<>();

  private static final String LOGTAG = LogUtils.getTag(GroupChatView.class.getSimpleName());

  private static final String OPEN_GROUPCHAT = "OPEN_GROUPCHAT";

  private static final String INTITIATE_GROUPCHAT = "INTITIATE_GROUPCHAT";

  private GroupChatListener mChatListener;

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    if (isExiting()) {
      return;
    }
    try {
      addChatEventListener(mChatService);
      ChatServiceConfiguration configuration = mChatService.getConfiguration();
      /* Set max label length */
      int maxMsgLength = configuration.getGroupChatMessageMaxLength();
      if (maxMsgLength > 0) {
        // Set the message composer max length
        InputFilter[] filterArray = new InputFilter[1];
        filterArray[0] = new InputFilter.LengthFilter(maxMsgLength);
        mComposeText.setFilters(filterArray);
      }
      mComposingManager =
          new IsComposingManager(configuration.getIsComposingTimeout(), getNotifyComposing());

    } catch (RcsServiceException e) {
      showExceptionThenExit(e);
    }
    if (LogUtils.isActive) {
      Log.d(LOGTAG, "onCreate");
    }
  }

  @Override
  public void onDestroy() {
    if (LogUtils.isActive) {
      Log.d(LOGTAG, "onDestroy");
    }
    if (mGroupChat != null) {
      try {
        mGroupChat.setComposingStatus(false);
      } catch (RcsServiceException e) {
        Log.w(LOGTAG, ExceptionUtil.getFullStackTrace(e));
      }
    }
    super.onDestroy();
  }

  @Override
  protected void onResume() {
    super.onResume();
    sChatIdOnForeground = mChatId;
  }

  @Override
  protected void onPause() {
    super.onPause();
    sChatIdOnForeground = null;
  }

  @Override
  public boolean processIntent(Intent intent) {
    String action = intent.getAction();
    if (LogUtils.isActive) {
      Log.d(LOGTAG, "processIntent: " + action);
    }
    String oldChatId = mChatId;
    try {
      switch ((GroupChatMode) intent.getSerializableExtra(EXTRA_MODE)) {
        case OUTGOING:
          /* Initiate a Group Chat: Get subject */
          mSubject = intent.getStringExtra(GroupChatView.EXTRA_SUBJECT);
          updateGroupChatViewTitle(mSubject);
          /* Get the list of participants */
          ContactUtil contactUtil = ContactUtil.getInstance(this);
          List<String> contacts = intent.getStringArrayListExtra(GroupChatView.EXTRA_PARTICIPANTS);
          if (contacts == null || contacts.isEmpty()) {
            showMessageThenExit(R.string.label_invalid_contacts);
            return false;
          }
          for (String contact : contacts) {
            mParticipants.add(contactUtil.formatContact(contact));
          }
          if (mParticipants.isEmpty()) {
            showMessageThenExit(R.string.label_invalid_contacts);
            return false;
          }
          return initiateGroupChat(oldChatId == null);

        case OPEN:
          /* Open an existing session from the history log */
          mChatId = intent.getStringExtra(GroupChatIntent.EXTRA_CHAT_ID);
          mGroupChat = mChatService.getGroupChat(mChatId);
          if (mGroupChat == null) {
            if (LogUtils.isActive) {
              Log.e(LOGTAG, "Groupchat not found for Id=".concat(mChatId));
            }
            showMessageThenExit(R.string.label_session_not_found);
            return false;
          }
          setCursorLoader(oldChatId == null);
          sChatIdOnForeground = mChatId;
          mSubject = mGroupChat.getSubject();
          updateGroupChatViewTitle(mSubject);
          /* Set list of participants */
          mParticipants = mGroupChat.getParticipants().keySet();
          if (LogUtils.isActive) {
            Log.i(LOGTAG, "processIntent chatId=" + mChatId + " subject='" + mSubject + "'");
          }
          return true;

        case INCOMING:
          String rxChatId = intent.getStringExtra(GroupChatIntent.EXTRA_CHAT_ID);
          if (GroupChatIntent.ACTION_NEW_GROUP_CHAT_MESSAGE.equals(action)) {
            String rxMsgId = intent.getStringExtra(GroupChatIntent.EXTRA_MESSAGE_ID);
            mChatService.markMessageAsRead(rxMsgId);
          }
          mChatId = rxChatId;
          mGroupChat = mChatService.getGroupChat(mChatId);
          if (mGroupChat == null) {
            showMessageThenExit(R.string.label_session_not_found);
            return false;
          }
          setCursorLoader(oldChatId == null);
          sChatIdOnForeground = mChatId;
          ContactId contact = mGroupChat.getRemoteContact();
          mSubject = mGroupChat.getSubject();
          updateGroupChatViewTitle(mSubject);
          mParticipants = mGroupChat.getParticipants().keySet();
          /* Display accept/reject dialog */
          if (GroupChat.State.INVITED == mGroupChat.getState()) {
            displayAcceptRejectDialog(contact);
          }
          if (LogUtils.isActive) {
            Log.d(LOGTAG, "New group chat for chatId ".concat(mChatId));
          }
          return true;
      }

    } catch (RcsServiceException e) {
      showExceptionThenExit(e);
    }
    return false;
  }

  @Override
  public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) {
    super.onCreateContextMenu(menu, v, menuInfo);
    /* Get the list item position. */
    AdapterContextMenuInfo info = (AdapterContextMenuInfo) menuInfo;
    Cursor cursor = (Cursor) mAdapter.getItem(info.position);
    menu.add(0, GROUPCHAT_MENU_ITEM_DELETE, 0, R.string.menu_delete_message);
    Direction direction =
        Direction.valueOf(cursor.getInt(cursor.getColumnIndexOrThrow(Message.DIRECTION)));
    if (Direction.OUTGOING == direction) {
      menu.add(0, GROUPCHAT_MENU_ITEM_VIEW_GC_INFO, 1, R.string.menu_view_groupdelivery);
      // TODO depending on mime-type and provider ID, allow user to view file image
    }
  }

  @Override
  public boolean onContextItemSelected(MenuItem item) {
    AdapterContextMenuInfo info = (AdapterContextMenuInfo) item.getMenuInfo();
    Cursor cursor = (Cursor) (mAdapter.getItem(info.position));
    String messageId = cursor.getString(cursor.getColumnIndexOrThrow(HistoryLog.ID));
    if (LogUtils.isActive) {
      Log.d(LOGTAG, "onContextItemSelected Id=".concat(messageId));
    }
    int providerId = cursor.getInt(cursor.getColumnIndexOrThrow(HistoryLog.PROVIDER_ID));
    switch (item.getItemId()) {
      case GROUPCHAT_MENU_ITEM_VIEW_GC_INFO:
        GroupDeliveryInfoList.startActivity(this, messageId);
        return true;

      case GROUPCHAT_MENU_ITEM_DELETE:
        try {
          if (ChatLog.Message.HISTORYLOG_MEMBER_ID == providerId) {
            mChatService.deleteMessage(messageId);
          } else {
            mFileTransferService.deleteFileTransfer(messageId);
          }
        } catch (RcsServiceException e) {
          showException(e);
        }
        return true;

      default:
        return super.onContextItemSelected(item);
    }
  }

  /**
   * Update the view title
   *
   * @param subject the group chat subject or null
   */
  private void updateGroupChatViewTitle(String subject) {
    if (!TextUtils.isEmpty(subject)) {
      setTitle(getString(R.string.title_group_chat) + " '" + mSubject + "'");
    }
  }

  @Override
  public Loader<Cursor> onCreateLoader(int id, Bundle arg) {
    /* Create a new CursorLoader with the following query parameters. */
    return new CursorLoader(
        this,
        mUriHistoryProvider,
        PROJ_CHAT_MSG,
        WHERE_CLAUSE,
        new String[] {mChatId},
        ORDER_CHAT_MSG);
  }

  /**
   * Display notification to accept or reject invitation
   *
   * @param remote remote contact
   */
  private void displayAcceptRejectDialog(ContactId remote) {
    /* Manual accept */
    AlertDialog.Builder builder = new AlertDialog.Builder(this);
    builder.setTitle(R.string.title_group_chat);
    String from = RcsContactUtil.getInstance(this).getDisplayName(remote);
    String topic = (TextUtils.isEmpty(mSubject)) ? getString(R.string.label_no_subject) : mSubject;
    String msg = getString(R.string.label_gc_from_subject, from, topic);
    builder.setMessage(msg);
    builder.setCancelable(false);
    builder.setIcon(R.drawable.ri_notif_chat_icon);
    builder.setPositiveButton(
        R.string.label_accept,
        new android.content.DialogInterface.OnClickListener() {
          public void onClick(DialogInterface dialog, int which) {
            try {
              /* Accept the invitation */
              mGroupChat.openChat();
            } catch (RcsServiceException e) {
              showExceptionThenExit(e);
            }
          }
        });
    builder.setNegativeButton(
        R.string.label_decline,
        new android.content.DialogInterface.OnClickListener() {
          public void onClick(DialogInterface dialog, int which) {
            /*
             * Let session die by timeout. Exit activity
             */
            finish();
          }
        });
    registerDialog(builder.show());
  }

  /**
   * get a set of contact from a set of participant info
   *
   * @param setOfParticipant a set of participant info
   * @return a set of contact
   */
  private Set<String> getSetOfParticipants(Map<ContactId, ParticipantStatus> setOfParticipant) {
    Set<String> result = new HashSet<>();
    if (setOfParticipant.size() != 0) {
      for (ContactId contact : setOfParticipant.keySet()) {
        // TODO consider status ?
        result.add(contact.toString());
      }
    }
    return result;
  }

  /**
   * Initiate the group chat and open a progress dialog waiting for the session to start
   *
   * @return True if successful
   */
  private boolean initiateGroupChat(boolean firstLoad) {
    /* Initiate the group chat session in background */
    try {
      mGroupChat = mChatService.initiateGroupChat(new HashSet<>(mParticipants), mSubject);
      mChatId = mGroupChat.getChatId();
      setCursorLoader(firstLoad);
      sChatIdOnForeground = mChatId;
    } catch (RcsServiceException e) {
      showExceptionThenExit(e);
      return false;
    }
    /* Display a progress dialog waiting for the session to start */
    mProgressDialog = showProgressDialog(getString(R.string.label_command_in_progress));
    mProgressDialog.setOnCancelListener(
        new OnCancelListener() {
          public void onCancel(DialogInterface dialog) {
            Utils.displayToast(
                GroupChatView.this, getString(R.string.label_chat_initiation_canceled));
            quitSession();
          }
        });
    return true;
  }

  private void quitSession() {
    try {
      /* check if the session is not already stopped */
      if (mGroupChat != null) {
        mGroupChat.leave();
      }
    } catch (RcsServiceException e) {
      showException(e);

    } finally {
      mGroupChat = null;
      finish();
    }
  }

  /** Add participants to be invited in the session */
  private void addParticipants() {
    /* Build list of available contacts not already in the conference */
    Set<ContactId> availableParticipants = new HashSet<>();
    try {
      Set<RcsContact> contacts = getContactApi().getRcsContacts();
      for (RcsContact rcsContact : contacts) {
        ContactId contact = rcsContact.getContactId();
        if (mGroupChat.isAllowedToInviteParticipant(contact)) {
          availableParticipants.add(contact);
        }
      }
    } catch (RcsServiceException e) {
      showException(e);
      return;
    }
    /* Check if some participants are available */
    if (availableParticipants.size() == 0) {
      showMessage(R.string.label_no_participant_found);
      return;
    }
    /* Display contacts */
    final List<String> selectedParticipants = new ArrayList<>();
    final CharSequence[] items = new CharSequence[availableParticipants.size()];
    int i = 0;
    for (ContactId contact : availableParticipants) {
      items[i++] = contact.toString();
    }
    AlertDialog.Builder builder = new AlertDialog.Builder(this);
    builder.setTitle(R.string.label_select_contacts);
    builder.setCancelable(true);
    builder.setMultiChoiceItems(
        items,
        null,
        new DialogInterface.OnMultiChoiceClickListener() {
          public void onClick(DialogInterface dialog, int which, boolean isChecked) {
            String c = (String) items[which];
            if (isChecked) {
              selectedParticipants.add(c);
            } else {
              selectedParticipants.remove(c);
            }
          }
        });
    builder.setNegativeButton(R.string.label_cancel, null);
    builder.setPositiveButton(
        R.string.label_ok,
        new DialogInterface.OnClickListener() {
          public void onClick(DialogInterface dialog, int position) {
            /* Add new participants in the session in background */
            try {
              int max = mGroupChat.getMaxParticipants() - 1;
              int connected = mGroupChat.getParticipants().size();
              int limit = max - connected;
              if (selectedParticipants.size() > limit) {
                showMessage(R.string.label_max_participants);
                return;
              }
              Set<ContactId> contacts = new HashSet<>();
              ContactUtil contactUtils = ContactUtil.getInstance(GroupChatView.this);
              for (String participant : selectedParticipants) {
                contacts.add(contactUtils.formatContact(participant));
              }
              /* Add participants */
              mGroupChat.inviteParticipants(contacts);

            } catch (RcsServiceException e) {
              showException(e);
            }
          }
        });
    registerDialog(builder.show());
  }

  @Override
  public boolean onCreateOptionsMenu(Menu menu) {
    MenuInflater inflater = new MenuInflater(getApplicationContext());
    inflater.inflate(R.menu.menu_group_chat, menu);
    return true;
  }

  @Override
  public boolean onPrepareOptionsMenu(Menu menu) {
    MenuItem menuItemParticipants = menu.findItem(R.id.menu_participants);
    MenuItem menuItemSendFile = menu.findItem(R.id.menu_send_file);
    MenuItem menuItemLeave = menu.findItem(R.id.menu_close_session);
    try {
      if (mGroupChat != null) {
        menuItemParticipants.setEnabled(mGroupChat.isAllowedToInviteParticipants());
        menuItemLeave.setEnabled(mGroupChat.isAllowedToLeave());
        FileTransferService fileTransferService = getFileTransferApi();
        menuItemSendFile.setEnabled(
            fileTransferService.isAllowedToTransferFileToGroupChat(mChatId));
      } else {
        menuItemParticipants.setEnabled(false);
        menuItemSendFile.setEnabled(false);
        menuItemLeave.setEnabled(false);
      }
    } catch (RcsServiceException e) {
      showException(e);
    }
    return true;
  }

  @Override
  public boolean onOptionsItemSelected(MenuItem item) {
    try {
      switch (item.getItemId()) {
        case R.id.menu_insert_smiley:
          AlertDialog alert =
              Smileys.showSmileyDialog(
                  this, mComposeText, getResources(), getString(R.string.menu_insert_smiley));
          registerDialog(alert);
          break;

        case R.id.menu_participants:
          alert =
              Utils.showList(
                  this,
                  getString(R.string.menu_participants),
                  getSetOfParticipants(mGroupChat.getParticipants()));
          registerDialog(alert);
          break;

        case R.id.menu_add_participant:
          addParticipants();
          break;

        case R.id.menu_quicktext:
          addQuickText();
          break;

        case R.id.menu_send_file:
          SendGroupFile.startActivity(this, mChatId);
          break;

        case R.id.menu_send_geoloc:
          getGeoLoc();
          break;

        case R.id.menu_showus_map:
          DisplayGeoloc.showContactsOnMap(this, mGroupChat.getParticipants().keySet());
          break;

        case R.id.menu_close_session:
          AlertDialog.Builder builder = new AlertDialog.Builder(this);
          builder.setTitle(R.string.title_chat_exit);
          builder.setPositiveButton(
              R.string.label_ok,
              new DialogInterface.OnClickListener() {
                public void onClick(DialogInterface dialog, int which) {
                  if (mGroupChat != null) {
                    try {
                      mGroupChat.leave();
                    } catch (RcsServiceException e) {
                      showExceptionThenExit(e);
                    }
                  }
                  GroupChatView.this.finish();
                }
              });
          builder.setNegativeButton(R.string.label_cancel, null);
          builder.setCancelable(true);
          registerDialog(builder.show());
          break;
      }

    } catch (RcsServiceException e) {
      showException(e);
    }
    return true;
  }

  private void hideProgressDialog() {
    if (mProgressDialog != null && mProgressDialog.isShowing()) {
      mProgressDialog.dismiss();
      mProgressDialog = null;
    }
  }

  /**
   * Initiate a new Group Chat
   *
   * @param ctx context
   * @param subject subject
   * @param participants list of participants
   */
  public static void initiateGroupChat(
      Context ctx, String subject, ArrayList<String> participants) {
    Intent intent = new Intent(ctx, GroupChatView.class);
    intent.setAction(INTITIATE_GROUPCHAT);
    intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
    intent.putStringArrayListExtra(GroupChatView.EXTRA_PARTICIPANTS, participants);
    intent.putExtra(GroupChatView.EXTRA_MODE, GroupChatMode.OUTGOING);
    intent.putExtra(GroupChatView.EXTRA_SUBJECT, subject);
    ctx.startActivity(intent);
  }

  /**
   * Open a Group Chat
   *
   * @param ctx The context.
   * @param chatId The chat ID.
   */
  public static void openGroupChat(Context ctx, String chatId) {
    Intent intent = new Intent(ctx, GroupChatView.class);
    intent.setAction(OPEN_GROUPCHAT);
    intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
    intent.putExtra(GroupChatView.EXTRA_MODE, GroupChatMode.OPEN);
    intent.putExtra(GroupChatIntent.EXTRA_CHAT_ID, chatId);
    ctx.startActivity(intent);
  }

  /**
   * Forge intent to notify Group Chat message
   *
   * @param ctx The context.
   * @param newgroupChatMessage The original intent.
   * @param chatId the chat ID
   * @return intent
   */
  public static Intent forgeIntentNewMessage(
      Context ctx, Intent newgroupChatMessage, String chatId) {
    newgroupChatMessage.setClass(ctx, GroupChatView.class);
    newgroupChatMessage.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_NEW_TASK);
    newgroupChatMessage.putExtra(GroupChatView.EXTRA_MODE, GroupChatMode.INCOMING);
    newgroupChatMessage.putExtra(GroupChatIntent.EXTRA_CHAT_ID, chatId);
    return newgroupChatMessage;
  }

  /**
   * Forge intent to notify new Group Chat
   *
   * @param ctx The context.
   * @param invitation The original intent.
   * @return intent
   */
  public static Intent forgeIntentInvitation(Context ctx, Intent invitation) {
    invitation.setClass(ctx, GroupChatView.class);
    invitation.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_NEW_TASK);
    invitation.putExtra(GroupChatView.EXTRA_MODE, GroupChatMode.INCOMING);
    return invitation;
  }

  @Override
  public ChatMessage sendMessage(String message) throws RcsServiceException {
    if (LogUtils.isActive) {
      Log.d(LOGTAG, "sendTextMessage: ".concat(message));
    }
    return mGroupChat.sendMessage(message);
  }

  @Override
  public ChatMessage sendMessage(Geoloc geoloc) throws RcsServiceException {
    if (LogUtils.isActive) {
      Log.d(LOGTAG, "sendGeolocMessage: ".concat(geoloc.toString()));
    }
    return mGroupChat.sendMessage(geoloc);
  }

  @Override
  public void addChatEventListener(ChatService chatService) throws RcsServiceException {
    mChatService.addEventListener(mChatListener);
  }

  @Override
  public void removeChatEventListener(ChatService chatService) throws RcsServiceException {
    mChatService.removeEventListener(mChatListener);
  }

  @Override
  public boolean isSingleChat() {
    return false;
  }

  @Override
  public INotifyComposing getNotifyComposing() {
    return new INotifyComposing() {
      public void setTypingStatus(boolean isTyping) {
        try {
          if (mGroupChat != null) {
            mGroupChat.setComposingStatus(isTyping);
            if (LogUtils.isActive) {
              Log.d(LOGTAG, "sendIsComposingEvent ".concat(String.valueOf(isTyping)));
            }
          }
        } catch (RcsGenericException e) {
          showException(e);
        }
      }
    };
  }

  @Override
  public void initialize() {
    mChatListener =
        new GroupChatListener() {

          @Override
          public void onMessageStatusChanged(
              String chatId,
              String mimeType,
              String msgId,
              Content.Status status,
              Content.ReasonCode reasonCode) {
            if (LogUtils.isActive) {
              Log.i(
                  LOGTAG,
                  "onMessageStatusChanged chatId="
                      + chatId
                      + " mime-type="
                      + mimeType
                      + " msgId="
                      + msgId
                      + " status="
                      + status
                      + " reason="
                      + reasonCode);
            }
          }

          // Callback called when an Is-composing event has been received
          public void onComposingEvent(String chatId, ContactId contact, boolean status) {
            // Discard event if not for current chatId
            if (!mChatId.equals(chatId)) {
              return;
            }
            displayComposingEvent(contact, status);
          }

          @Override
          public void onParticipantStatusChanged(
              String chatId, ContactId contact, ParticipantStatus status) {
            if (LogUtils.isActive) {
              Log.d(
                  LOGTAG,
                  "onParticipantStatusChanged chatId="
                      + chatId
                      + " contact="
                      + contact
                      + " status="
                      + status);
            }
          }

          @Override
          public void onMessageGroupDeliveryInfoChanged(
              String chatId,
              ContactId contact,
              String mimeType,
              String msgId,
              GroupDeliveryInfo.Status status,
              GroupDeliveryInfo.ReasonCode reasonCode) {
            if (LogUtils.isActive) {
              Log.d(
                  LOGTAG,
                  "onMessageGroupDeliveryInfoChanged chatId="
                      + chatId
                      + " contact="
                      + contact
                      + " msgId="
                      + msgId
                      + " status="
                      + status
                      + " reason="
                      + reasonCode);
            }
          }

          @Override
          public void onStateChanged(
              String chatId, final GroupChat.State state, GroupChat.ReasonCode reasonCode) {
            if (LogUtils.isActive) {
              Log.d(
                  LOGTAG,
                  "onStateChanged chatId=" + chatId + " state=" + state + " reason=" + reasonCode);
            }
            /* Discard event if not for current chatId */
            if (mChatId == null || !mChatId.equals(chatId)) {
              return;
            }
            final String _reasonCode = RiApplication.sGroupChatReasonCodes[reasonCode.toInt()];
            mHandler.post(
                new Runnable() {
                  public void run() {
                    switch (state) {
                      case STARTED:
                        /* Session is well established : hide progress dialog. */
                        hideProgressDialog();
                        break;

                      case ABORTED:
                        showMessageThenExit(getString(R.string.label_chat_aborted, _reasonCode));
                        break;

                      case REJECTED:
                        showMessageThenExit(getString(R.string.label_chat_rejected, _reasonCode));
                        break;

                      case FAILED:
                        showMessageThenExit(getString(R.string.label_chat_failed, _reasonCode));
                        break;

                      default:
                    }
                  }
                });
          }

          @Override
          public void onDeleted(Set<String> chatIds) {
            if (LogUtils.isActive) {
              Log.i(LOGTAG, "onDeleted chatIds=".concat(Arrays.toString(chatIds.toArray())));
            }
          }

          @Override
          public void onMessagesDeleted(String chatId, Set<String> msgIds) {
            if (LogUtils.isActive) {
              Log.i(
                  LOGTAG,
                  "onMessagesDeleted chatId="
                      + chatId
                      + " msgIds="
                      + Arrays.toString(msgIds.toArray()));
            }
          }
        };
  }
}