Android 如何使用Twilio邀请用户访问新创建的私人聊天频道？

我创建了一个私人频道，并加入了该频道。我喜欢邀请其他用户加入该频道并聊天。要清楚，这应该是两个成员之间的聊天

public class MainActivity extends AppCompatActivity {
        /*
       Change this URL to match the token URL for your Twilio Function
    */
    final static String SERVER_TOKEN_URL = "https://example.com/twilio/token/";

    final static String MY_CHANNEL_NAME = "testchat1234567810";
    final static String TAG = "TwilioChat";

    // Update this identity for each individual user, for instance after they login
    private String mIdentity ;
    private String accessToken;
    private RecyclerView mMessagesRecyclerView;
    private MessagesAdapter mMessagesAdapter;
    private ArrayList<Message> mMessages = new ArrayList<>();

    private EditText mWriteMessageEditText;
    private Button mSendChatMessageButton;

    private ChatClient mChatClient;

    private Channel mGeneralChannel;


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mMessagesRecyclerView = (RecyclerView) findViewById(R.id.messagesRecyclerView);
        LinearLayoutManager layoutManager = new LinearLayoutManager(this);
        // for a chat app, show latest at the bottom
        layoutManager.setStackFromEnd(true);
        mMessagesRecyclerView.setLayoutManager(layoutManager);

        mMessagesAdapter = new MessagesAdapter();
        mMessagesRecyclerView.setAdapter(mMessagesAdapter);

        mWriteMessageEditText = (EditText) findViewById(R.id.writeMessageEditText);

        mSendChatMessageButton = (Button) findViewById(R.id.sendChatMessageButton);

        mSendChatMessageButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                createOrJoinChannel();
                if (mGeneralChannel != null) {

                    String messageBody = mWriteMessageEditText.getText().toString();
                    Message.Options options = Message.options().withBody(messageBody);
                    // mGeneralChannel.getMembers().add();
                    Members members = mGeneralChannel.getMembers();
                    if (members != null) {
                        ArrayList<Member> list = (ArrayList<Member>) members.getMembersList();
                        for (int i = 0; i < list.size(); i++) {
                            Log.i(TAG, "member " + i + list.get(i).getIdentity());
                        }
                    }
                    mGeneralChannel.getMembers().inviteByIdentity("user1@gmail.com", new StatusListener() {
                        @Override
                        public void onSuccess() {
                            Log.d(TAG, "User Invited on send!");

                        }

                        @Override
                        public void onError(ErrorInfo errorInfo) {
                            Log.i(TAG, "chats: inviting user" + errorInfo.getMessage());
                        }
                    });

                    mGeneralChannel.getMembersCount(new CallbackListener<Long>() {
                        @Override
                        public void onSuccess(Long aLong) {
                            Log.e("member count >>", aLong + "");
                        }
                    });
                    mGeneralChannel.getMessages().sendMessage(options, new CallbackListener<Message>() {
                        @Override
                        public void onSuccess(Message message) {
                            MainActivity.this.runOnUiThread(new Runnable() {
                                @Override
                                public void run() {
                                    Log.d(TAG, "Message created");
                                    // need to modify user interface elements on the UI thread
                                    mWriteMessageEditText.setText("");
                                }
                            });
                        }
                    });
                }
            }
        });

        retrieveAccessTokenfromServer();



    }



    private void retrieveAccessTokenfromServer() {
        String deviceId = Settings.Secure.getString(getContentResolver(), Settings.Secure.ANDROID_ID);
Log.e("deviceid >>",deviceId);
        String tokenURL = SERVER_TOKEN_URL + deviceId;

        Ion.with(this)
                .load(tokenURL)
                .asJsonObject()
                .setCallback(new FutureCallback<JsonObject>() {
                    @Override
                    public void onCompleted(Exception e, JsonObject result) {
                        Log.e("result >>", result.toString() + "");
                        if (e == null) {
                            mIdentity = result.get("identity").getAsString();
                            accessToken = result.get("token").getAsString();
                            setTitle(mIdentity);

                            ChatClient.Properties.Builder builder = new ChatClient.Properties.Builder();
                         //   ChatClient.setLogLevel(Log.VERBOSE);
                            ChatClient.Properties props = builder.createProperties();
                            ChatClient.create(MainActivity.this, accessToken, props, mChatClientCallback);

                        } else {
                            Toast.makeText(MainActivity.this,
                                    R.string.error_retrieving_access_token, Toast.LENGTH_SHORT)
                                    .show();
                        }
                    }
                });
    }

    private CallbackListener<ChatClient> mChatClientCallback =
            new CallbackListener<ChatClient>() {
                @Override
                public void onSuccess(ChatClient chatClient) {
                    mChatClient = chatClient;
                    //   createOrJoinChannel();
                    //  loadChannels();
                    Log.d(TAG, "Success creating Twilio Chat Client");
                }

                @Override
                public void onError(ErrorInfo errorInfo) {
                    Log.e(TAG, "Error creating Twilio Chat Client: " + errorInfo.getMessage());
                }


            };



    private void createOrJoinChannel() {
        //Only SID or unique name of channel can be supplied as parameter
        mChatClient.getChannels().getChannel(MY_CHANNEL_NAME, new CallbackListener<Channel>() {

            @Override
            public void onSuccess(Channel channel) {
                if (channel != null) {
                    if (channel.getStatus() == Channel.ChannelStatus.JOINED) {
                        // already in the channel, load the messages
                        mGeneralChannel = channel;
                        mGeneralChannel.addListener(mDefaultChannelListener);
                    } else if (channel.getStatus() == Channel.ChannelStatus.NOT_PARTICIPATING) {
                        // already in the channel, load the messages
                        mGeneralChannel = channel;
                        mGeneralChannel.addListener(mDefaultChannelListener);
                    } else {
                        // join the channel
                        joinChannel(channel);
                    }

                } else {
                    Log.i(TAG, "Error occurred in getting channel");
                }
            }

            @Override
            public void onError(ErrorInfo errorInfo) {
                Log.i(TAG, "Error retrieving channel: " + errorInfo.getMessage());
                createChannel();
            }

        });
    }

    private void joinChannel(final Channel channel) {
        Log.i(TAG, "inside join channel" + channel.getUniqueName());
        Log.i(TAG, "channel status: " + channel.getStatus());

        Members members = channel.getMembers();
        if (members != null) {
            ArrayList<Member> list = (ArrayList<Member>) members.getMembersList();
            for (int i = 0; i < list.size(); i++) {
                Log.i(TAG, "member " + i + list.get(i).getIdentity());
            }
        } else {
            Log.i(TAG, "null object"); //Getting this even when I get
            //"Member already exists" error
        }
        channel.join(new StatusListener() {
            @Override
            public void onSuccess() {
                mGeneralChannel = channel;
                mGeneralChannel.addListener(mDefaultChannelListener);
            }

            @Override
            public void onError(ErrorInfo errorInfo) {
                //Error joining channel: Member already exists
                Log.i(TAG, "Error joining channel: " + errorInfo.getMessage());
            }
        });
    }


    private void createChannel() {
        mChatClient.getChannels().createChannel(MY_CHANNEL_NAME,
                Channel.ChannelType.PUBLIC, new CallbackListener<Channel>() {
                    @Override
                    public void onSuccess(final Channel channel) {
                        if (channel != null) {
                               /* channel.getMembersCount(new CallbackListener<Long>() {
                                    @Override
                                    public void onSuccess(Long aLong) {
                                        Log.e("member count >>",aLong+"");
                                    }
                                });*/
                            channel.getMembers().inviteByIdentity("user1@gmail.com", new StatusListener() {
                                @Override
                                public void onSuccess() {
                                    Log.d(TAG, "User Invited!");
                                }

                                @Override
                                public void onError(ErrorInfo errorInfo) {
                                    Log.i(TAG, "chats: inviting user" + errorInfo.getMessage());
                                }
                            });
                            channel.join(new StatusListener() {
                                @Override
                                public void onSuccess() {

                                }
                            });
                            setUniqueNameAndJoin(channel);
                        }
                    }

                    @Override
                    public void onError(ErrorInfo errorInfo) {
                        Log.i(TAG, "chats: " + "Unique name could not be set: " + errorInfo.getMessage());
                    }
                });
    }

    private void setUniqueNameAndJoin(final Channel channel) {
        channel.setUniqueName(MY_CHANNEL_NAME, new StatusListener() {
            @Override
            public void onSuccess() {
                Log.i(TAG, "channel with unique name created " + channel.getUniqueName());
                joinChannel(channel);
            }

            @Override
            public void onError(ErrorInfo errorInfo) {
                super.onError(errorInfo);
            }
        });
    }

    private ChannelListener mDefaultChannelListener = new ChannelListener() {


        @Override
        public void onMessageAdded(final Message message) {
            Log.d(TAG, "Message added");
            MainActivity.this.runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    // need to modify user interface elements on the UI thread
                    mMessages.add(message);
                    mMessagesAdapter.notifyDataSetChanged();
                }
            });

        }

        @Override
        public void onMessageUpdated(Message message, Message.UpdateReason updateReason) {
            Log.d(TAG, "Message updated: " + message.getMessageBody());
        }

        @Override
        public void onMessageDeleted(Message message) {
            Log.d(TAG, "Message deleted");
        }

        @Override
        public void onMemberAdded(Member member) {
            Log.d(TAG, "Member added: " + member.getIdentity());
        }

        @Override
        public void onMemberUpdated(Member member, Member.UpdateReason updateReason) {
            Log.d(TAG, "Member updated: " + member.getIdentity());
        }

        @Override
        public void onMemberDeleted(Member member) {
            Log.d(TAG, "Member deleted: " + member.getIdentity());
        }

        @Override
        public void onTypingStarted(Channel channel, Member member) {
            Log.d(TAG, "Started Typing: " + member.getIdentity());
        }

        @Override
        public void onTypingEnded(Channel channel, Member member) {
            Log.d(TAG, "Ended Typing: " + member.getIdentity());
        }

        @Override
        public void onSynchronizationChanged(Channel channel) {

        }
    };


    class MessagesAdapter extends RecyclerView.Adapter<MessagesAdapter.ViewHolder> {

        class ViewHolder extends RecyclerView.ViewHolder {

            public TextView mMessageTextView;

            public ViewHolder(TextView textView) {
                super(textView);
                mMessageTextView = textView;
            }
        }

        public MessagesAdapter() {

        }

        @Override
        public MessagesAdapter
                .ViewHolder onCreateViewHolder(ViewGroup parent,
                                               int viewType) {
            TextView messageTextView = (TextView) LayoutInflater.from(parent.getContext())
                    .inflate(R.layout.message_text_view, parent, false);
            return new ViewHolder(messageTextView);
        }

        @Override
        public void onBindViewHolder(ViewHolder holder, int position) {
            Message message = mMessages.get(position);
            String messageText = String.format("%s: %s", message.getAuthor(), message.getMessageBody());
            holder.mMessageTextView.setText(messageText);

        }

        @Override
        public int getItemCount() {
            return mMessages.size();
        }
    }



}

public类MainActivity扩展了AppCompatActivity{
/*
更改此URL以匹配Twilio函数的令牌URL
*/
最终静态字符串服务器\u令牌\u URL=”https://example.com/twilio/token/";
最终静态字符串MY_CHANNEL_NAME=“testchat1234567810”；
最终静态字符串标记=“TwilioChat”；
//为每个用户更新此标识，例如在他们登录后
私有实体；
私有字符串访问令牌；
私人RecyclerView mMessagesRecyclerView；
私有消息适配器mMessagesAdapter；
private ArrayList mMessages=new ArrayList（）；
私有EditText mWriteMessageEditText；
私有按钮mSendChatMessageButton；
私人聊天客户端mChatClient；
专用信道管理通用信道；
@凌驾
创建时受保护的void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
setContentView（R.layout.activity_main）；
mMessageRecyclerView=（RecyclerView）findViewById（R.id.messagesRecyclerView）；
LinearLayoutManager layoutManager=新的LinearLayoutManager（此）；
//对于聊天应用程序，请在底部显示最新信息
layoutManager.setStackFromEnd（true）；
msMessageRecycleService.setLayoutManager（layoutManager）；
mMessagesAdapter=newmessagesadapter（）；
MMessagesRecyclererview.setAdapter（mMessagesAdapter）；
mWriteMessageEditText=（EditText）findViewById（R.id.writeMessageEditText）；
mSendChatMessageButton=（按钮）findViewById（R.id.sendChatMessageButton）；
mSendChatMessageButton.setOnClickListener（新视图.OnClickListener（）{
@凌驾
公共void onClick（视图）{
createOrJoinChannel（）；
if（mGeneralChannel！=null）{
字符串messageBody=mWriteMessageEditText.getText（）.toString（）；
Message.Options=Message.Options（）.withBody（messageBody）；
//mGeneralChannel.getMembers（）.add（）；
Members=mGeneralChannel.getMembers（）；
如果（成员！=null）{
ArrayList=（ArrayList）members.getMembersList（）；
对于（int i=0；i>”，沿+“”）；
}
});
mGeneralChannel.getMessages（）.sendMessage（选项，新建CallbackListener（））{
@凌驾
成功时公共无效（消息）{
MainActivity.this.runOnUiThread（新的Runnable（）{
@凌驾
公开募捐{
Log.d（标记“消息已创建”）；
//需要修改UI线程上的用户界面元素
mWriteMessageEditText.setText（“”）；
}
});
}
});
}
}
});
retrieveAccessTokenfromServer（）；
}
私有void retrieveAccessTokenfromServer（）{
String deviceId=Settings.Secure.getString（getContentResolver（），Settings.Secure.ANDROID）；
Log.e（“deviceid>>”，deviceid）；
字符串tokenURL=服务器\令牌\ URL+设备ID；
（这个）离子
.load（令牌URL）
.asJsonObject（）
.setCallback（新的FutureCallback（）{
@凌驾
未完成公共无效（异常e，JsonObject结果）{
Log.e（“result>>”，result.toString（）+“”）；
如果（e==null）{
mIdentity=result.get（“标识”）.getAsString（）；
accessToken=result.get（“token”）.getAsString（）；
setTitle（中间实体）；
ChatClient.Properties.Builder=新建ChatClient.Properties.Builder（）；
//setLogLevel（Log.VERBOSE）；
ChatClient.Properties=builder.createProperties（）；
创建（MainActivity.this、accessToken、props、mChatClientCallback）；
}否则{
Toast.makeText（MainActivity.this，
R.string.error\u检索\u访问\u令牌，Toast.LENGTH\u SHORT）
.show（）；
}
}
});
}
专用CallbackListener mChatClientCallback=
新建CallbackListener（）{
@凌驾
成功时公共无效（ChatClient ChatClient）{
mChatClient=chatClient；