Rövid útmutató: Csevegés hozzáadása az alkalmazáshoz

Cikk
10/30/2023

Ismerkedés az Azure Communication Services szolgáltatással a Communication Services Chat SDK használatával valós idejű csevegés hozzáadásához az alkalmazáshoz. Ebben a rövid útmutatóban a Csevegő SDK használatával hozunk létre olyan csevegési szálakat, amelyek lehetővé teszik a felhasználók számára, hogy beszélgetéseket kezdeményezhessenek egymással. A csevegési fogalmakkal kapcsolatos további információkért tekintse meg a csevegés fogalmi dokumentációját.

Előfeltételek

Egy Azure-fiók, aktív előfizetéssel. Fiók ingyenes létrehozása.
Aktív Communication Services-erőforrás és kapcsolati sztring. Hozzon létre egy Communication Services-erőforrást.
Telepítse az Azure CLI-t.
Jegyezze fel a Communication Services-erőforrásvégpontot. A végpontot az Azure Portalról szerezheti be. Másik lehetőségként megtalálhatja a végpont URL-címét a kapcsolati sztring. Ez az URL-cím, amely utána endpoint= következik, és a következővel https://kezdődik: .
Felhasználói hozzáférési jogkivonat. Ügyeljen arra, hogy a hatókört csevegésre állítsa, és jegyezze fel a jogkivonat sztringet, valamint a user_id sztringet. Az Azure CLI használatával az alábbi parancsot is futtathatja a kapcsolati sztring egy felhasználó és egy hozzáférési jogkivonat létrehozásához.
```
az communication identity token issue --scope chat --connection-string "yourConnectionString"
```
További részletekért lásd: Hozzáférési jogkivonatok létrehozása és kezelése az Azure CLI használatával.

Beállítás

A bővítmény hozzáadása

Adja hozzá az Azure CLI Azure Communication Services-bővítményét a az extension parancs használatával.

az extension add --name communication

Be kell jelentkeznie az Azure CLI-be. Bejelentkezhet a az login parancs terminálról való futtatásával, és megadhatja a hitelesítő adatait.

(Nem kötelező) Azure CLI-identitásműveletek használata végpont vagy hozzáférési jogkivonat átadása nélkül

A végpont tárolása környezeti változóban

A környezeti változót AZURE_COMMUNICATION_ENDPOINT úgy konfigurálhatja, hogy az Azure CLI csevegőműveleteket használjon anélkül, hogy --endpoint a végponton kellene áthaladnia. Környezeti változó konfigurálásához nyisson meg egy konzolablakot, és válassza ki az operációs rendszert az alábbi lapokról. Cserélje le <yourEndpoint> a tényleges végpontra.

Nyisson meg egy konzolablakot, és írja be a következő parancsot:

setx AZURE_COMMUNICATION_ENDPOINT "<yourEndpoint>"

Miután hozzáadta a környezeti változót, előfordulhat, hogy újra kell indítania minden futó programot, amelynek szüksége lehet a környezeti változó beolvasására, beleértve a konzolablakot is. Ha például a Visual Studiót használja szerkesztőként, indítsa újra a Visual Studiót a példa futtatása előtt.

Szerkessze a .zshrcsaját , és adja hozzá a környezeti változót:

export AZURE_COMMUNICATION_ENDPOINT="<yourEndpoint>"

A környezeti változó hozzáadását követően futtassa a source ~/.zshrc parancsot a konzolablakban a módosítások érvénybe léptetéséhez. Ha megnyitott IDE-vel hozta létre a környezeti változót, előfordulhat, hogy be kell zárnia és újra meg kell nyitnia a szerkesztőt, az IDE-t vagy a rendszerhéjat a változó eléréséhez.

Szerkessze a .bash_profilesaját , és adja hozzá a környezeti változót:

export AZURE_COMMUNICATION_ENDPOINT="<yourEndpoint>"

A környezeti változó hozzáadását követően futtassa a source ~/.bash_profile parancsot a konzolablakban a módosítások érvénybe léptetéséhez. Ha megnyitott IDE-vel hozta létre a környezeti változót, előfordulhat, hogy be kell zárnia és újra meg kell nyitnia a szerkesztőt, az IDE-t vagy a rendszerhéjat a változó eléréséhez.

A hozzáférési jogkivonat tárolása környezeti változóban

A környezeti változót AZURE_COMMUNICATION_ACCESS_TOKEN úgy konfigurálhatja, hogy azure CLI-csevegési műveleteket használjon anélkül, hogy --access-token a hozzáférési jogkivonatot kellene átadnia. Környezeti változó konfigurálásához nyisson meg egy konzolablakot, és válassza ki az operációs rendszert az alábbi lapokról. Cserélje le <yourAccessToken> a tényleges hozzáférési jogkivonatra.

Nyisson meg egy konzolablakot, és írja be a következő parancsot:

setx AZURE_COMMUNICATION_ACCESS_TOKEN "<yourAccessToken>"

Szerkessze a .zshrcsaját , és adja hozzá a környezeti változót:

export AZURE_COMMUNICATION_ACCESS_TOKEN="<yourAccessToken>"

Szerkessze a .bash_profilesaját , és adja hozzá a környezeti változót:

export AZURE_COMMUNICATION_ACCESS_TOKEN="<yourAccessToken>"

Operations

Csevegési szál indítása

thread create A parancs használatával csevegőszálat hozhat létre.

az communication chat thread create --topic "<chatTopic>" --endpoint "<endpoint>" --access-token "<token>"

Ha a végpontot és a hozzáférési jogkivonatot a fenti környezeti változókban tárolta, nem kell átadnia őket a parancsnak.

az communication chat thread create --topic "<chatTopic>"

A téma témájának adására használható <chatTopic> . A témakört a csevegési szál létrehozása után a parancs használatával thread update-topic frissítheti.
Cserélje le <endpoint> az Azure Communication Services-végpontra.
Cserélje le <token> a korábban beszerzett hozzáférési jogkivonatot a futó identity token issue parancsra.

Csevegőszál témakörének frissítése

az communication chat thread update-topic --thread "<chatThreadId>" --topic "<chatTopic>" --endpoint "<endpoint>" --access-token "<token>"

Cserélje le <chatThreadId> a csevegési szál azonosítóját.
Cserélje le <chatTopic> a beállítani kívánt új csevegőtémakörre.
Cserélje le <endpoint> az Azure Communication Services-végpontra.
Cserélje le <token> a korábban beszerzett hozzáférési jogkivonatot a futó identity token issue parancsra.

Az összes csevegési szál listázása

A thread list parancs egy felhasználó csevegési szálainak listáját adja vissza.

az communication chat thread list --start-time "<startTime>" --endpoint "<endpoint>" --access-token "<token>"

A <startTime> csevegőüzenetek lekéréséhez szükség esetén megadhatja a legkorábbi időpontot.
Cserélje le <endpoint> az Azure Communication Services-végpontra.
Cserélje le <token> a korábban beszerzett hozzáférési jogkivonatot a futó identity token issue parancsra.

Üzenet küldése csevegési szálra

message send A paranccsal üzenetet küldhet a létrehozott csevegőszálnak, amelyet threadIda rendszer azonosított.

az communication chat message send --thread "<chatThreadId>" --display-name "<displayName>" --content "<content>" --message-type "<messageType>"  --endpoint "<endpoint>" --access-token "<token>"

Cserélje le <chatThreadId> a csevegési szál azonosítóját.
A csevegőüzenet tartalmának megadására szolgál <content> .
Az üzenet tartalomtípusának megadására használható <messageType> . A lehetséges értékek a következők: text és html. Ha nem ad meg értéket, az alapértelmezett érték a következő text.
A <displayName> feladó megjelenítendő nevének megadása opcionálisan.
Cserélje le <endpoint> az Azure Communication Services-végpontra.
Cserélje le <token> a korábban beszerzett hozzáférési jogkivonatot a futó identity token issue parancsra.

Csevegőüzenetek listázása csevegési szálon

A message list parancs visszaadja a csevegőszálban lévő csevegőüzenetek listáját.

az communication chat message list --thread "<chatThreadId>" --start-time "<startTime>" --endpoint "<endpoint>" --access-token "<token>"

Cserélje le <chatThreadId> a csevegési szál azonosítóját.
A <startTime> csevegőüzenetek lekéréséhez szükség esetén megadhatja a legkorábbi időpontot.
Cserélje le <endpoint> az Azure Communication Services-végpontra.
Cserélje le <token> a korábban beszerzett hozzáférési jogkivonatot a futó identity token issue parancsra.

Csevegőüzenet fogadása csevegőszálból

A csevegőüzeneteket a message list parancs használatával is lekérheti.

az communication chat message get --thread "<chatThreadId>" --message-id "<messageId>" --endpoint "<endpoint>" --access-token "<token>"

Cserélje le <chatThreadId> a csevegési szál azonosítóját.
Cserélje le <messageId> a lekérni kívánt üzenet azonosítójára.
Cserélje le <endpoint> az Azure Communication Services-végpontra.
Cserélje le <token> a korábban beszerzett hozzáférési jogkivonatot a futó identity token issue parancsra.

Olvasási visszaigazolás küldése

message receipt send A paranccsal olvasási visszaigazolási eseményt tehet közzé egy szálon egy felhasználó nevében.

az communication chat message receipt send --thread "<chatThreadId>" --message-id "<messageId>" --endpoint "<endpoint>" --access-token "<token>"

Cserélje le <chatThreadId> a csevegési szál azonosítóját.
Csere <messageId> az aktuális felhasználó által beolvasott legújabb üzenet azonosítójának megadásához.
Cserélje le <endpoint> az Azure Communication Services-végpontra.
Cserélje le <token> a korábban beszerzett hozzáférési jogkivonatot a futó identity token issue parancsra.

Felhasználó hozzáadása résztvevőként a csevegési szálhoz

Csevegési szál létrehozásakor felhasználókat vehet fel és távolíthat el belőle. A felhasználók hozzáadásával hozzáférést adhat nekik ahhoz, hogy üzeneteket tudjanak küldeni a csevegési szálra, és más résztvevőket vegyenek fel vagy távolíthassanak el. A parancs meghívása participant add előtt győződjön meg arról, hogy új hozzáférési jogkivonatot és identitást szerzett be a felhasználó számára.

az communication chat participant add --thread "<chatThreadId>" --user "<userId>" --display-name "<displayName>" --start-time "<startTime>" --endpoint "<endpoint>" --access-token "<token>"

Cserélje le <chatThreadId> a csevegési szál azonosítóját.
Cserélje le <userId> a userId azonosítót.
A <displayName> feladó megjelenítendő nevének megadása opcionálisan.
A <startTime> csevegőüzenetek lekéréséhez szükség esetén megadhatja a legkorábbi időpontot.
Cserélje le <endpoint> az Azure Communication Services-végpontra.
Cserélje le <token> a korábban beszerzett hozzáférési jogkivonatot a futó identity token issue parancsra.

Csevegési szál résztvevőinek listázása

A résztvevők hozzáadásához hasonlóan a résztvevőket egy szálból is listázhatja.

A parancs használatával participant list lekérheti a szál résztvevőit.

az communication chat participant list --thread "<chatThreadId>" --skip "<skip>" --endpoint "<endpoint>" --access-token "<token>"

Cserélje le <chatThreadId> a csevegési szál azonosítóját.
Lehetőség van <skip> arra, hogy a résztvevőket egy adott pozícióba ugorja a válaszban.
Cserélje le <endpoint> az Azure Communication Services-végpontra.
Cserélje le <token> a korábban beszerzett hozzáférési jogkivonatot a futó identity token issue parancsra.

Résztvevő eltávolítása csevegési szálból

A csevegés résztvevőit a "résztvevő eltávolítása" paranccsal távolíthatja el a csevegési szálból.

az communication chat participant remove --thread "<chatThreadId>" --user "<userId>" --endpoint "<endpoint>" --access-token "<token>"

Cserélje le <chatThreadId> a csevegési szál azonosítóját.
Cserélje le <userId> azt a userId azonosítót, amelyet el szeretne távolítani a csevegési szálból.
Cserélje le <endpoint> az Azure Communication Services-végpontra.
Cserélje le <token> a korábban beszerzett hozzáférési jogkivonatot a futó identity token issue parancsra.

Előfeltételek

Az első lépések előtt győződjön meg arról, hogy:

Azure-fiók létrehozása aktív előfizetéssel. További részletekért lásd : Fiók létrehozása ingyenesen.
Telepítse a Node.js Active LTS- és karbantartási LTS-verziókat.
Hozzon létre egy Azure Communication Services-erőforrást. További részletekért lásd : Azure Communication Services-erőforrás létrehozása. Ehhez a rövid útmutatóhoz rögzítenie kell az erőforrásvégpontot és a kapcsolati sztring.
Hozzon létre három Azure Communication Services-felhasználót, és adjon ki nekik egy felhasználói hozzáférési jogkivonatot. Ügyeljen arra, hogy a hatókört csevegésre állítsa, és jegyezze fel a jogkivonat sztringet, valamint a user_id sztringet. A teljes bemutató létrehoz egy szálat két kezdeti résztvevővel, majd hozzáad egy harmadik résztvevőt a szálhoz. Az Azure CLI használatával az alábbi parancsot is futtathatja a kapcsolati sztring egy felhasználó és egy hozzáférési jogkivonat létrehozásához.
```
az communication identity token issue --scope chat --connection-string "yourConnectionString"
```
További részletekért lásd: Hozzáférési jogkivonatok létrehozása és kezelése az Azure CLI használatával.

Beállítás

Új webalkalmazás létrehozása

Először nyissa meg a terminált vagy a parancsablakot, és hozzon létre egy új könyvtárat az alkalmazáshoz, és navigáljon hozzá.

mkdir chat-quickstart && cd chat-quickstart

Futtassa npm init -y a package.json fájl alapértelmezett beállításokkal való létrehozásához.

npm init -y

A csomagok telepítése

Az alábbi Communication Services SDK-k JavaScripthez való telepítéséhez használja a npm install parancsot.

npm install @azure/communication-common --save

npm install @azure/communication-identity --save

npm install @azure/communication-signaling --save

npm install @azure/communication-chat --save

A --save beállítás függőségként sorolja fel a tárat a package.json fájlban.

Az alkalmazás-keretrendszer beállítása

Ez a rövid útmutató csomaggal köti össze az alkalmazásegységeket. Futtassa a következő parancsot a telepítéshez, és sorolja fel fejlesztési függőségként a package.json fájlban:

npm install parcel --save-dev

Hozzon létre egy index.html fájlt a projekt gyökérkönyvtárában. Ezt a fájlt sablonként fogjuk használni a csevegési képesség hozzáadásához a JavaScripthez készült Azure Communication Chat SDK használatával.

<!DOCTYPE html>
<html>
  <head>
    <title>Communication Client - Chat Sample</title>
  </head>
  <body>
    <h4>Azure Communication Services</h4>
    <h1>Chat Quickstart</h1>
    <script src="./client.js" type="module"></script>
  </body>
</html>

Hozzon létre egy fájlt a projekt gyökérkönyvtárában client.js néven, amely tartalmazza a rövid útmutató alkalmazáslogikát.

Csevegőügyfél létrehozása

Ha csevegőügyfélt szeretne létrehozni a webalkalmazásban, a Communications Service-végpontot és az előfeltétel-lépések részeként létrehozott hozzáférési jogkivonatot fogja használni.

A felhasználói hozzáférési jogkivonatok lehetővé teszik olyan ügyfélalkalmazások létrehozását, amelyek közvetlenül hitelesítik magukat az Azure Communication Servicesben. Ez a rövid útmutató nem foglalja magában a szolgáltatásszint létrehozását a csevegőalkalmazás jogkivonatainak kezeléséhez. A csevegőarchitektúrával és a felhasználói hozzáférési jogkivonatokkal kapcsolatos további információkért tekintse meg a csevegési fogalmakat.

A client.js-ben az alábbi kódban található végpont és hozzáférési jogkivonat használatával adhat hozzá csevegési képességet a JavaScripthez készült Azure Communication Chat SDK használatával.


import { ChatClient } from '@azure/communication-chat';
import { AzureCommunicationTokenCredential } from '@azure/communication-common';

// Your unique Azure Communication service endpoint
let endpointUrl = '<replace with your resource endpoint>';
// The user access token generated as part of the pre-requisites
let userAccessToken = '<USER_ACCESS_TOKEN>';

let chatClient = new ChatClient(endpointUrl, new AzureCommunicationTokenCredential(userAccessToken));
console.log('Azure Communication Chat client created!');

Cserélje le az endpointUrl-t a Communication Services-erőforrásvégpontra. Ha még nem tette meg, tekintse meg az Azure Communication Services-erőforrás létrehozását.
Cserélje le a userAccessTokent a kiállított jogkivonatra.

A kód futtatása

Futtassa a következő parancsot az alkalmazás futtatásához:

npx parcel index.html

Nyissa meg a böngészőt, és lépjen a http://localhost:1234/. A böngészőn belüli fejlesztői eszközök konzolján az alábbiaknak kell megjelennie:

Azure Communication Chat client created!

Objektummodell

Az alábbi osztályok és felületek a JavaScripthez készült Azure Communication Services Chat SDK néhány fő funkcióját kezelik.

Name	Leírás
ChatClient	Ez az osztály a Csevegés funkcióhoz szükséges. Példányosíthatja az előfizetés adataival, és használatával létrehozhat, lekérhet, törölhet szálakat, és feliratkozhat csevegési eseményekre.
ChatThreadClient	Ez az osztály szükséges a Csevegési szál funkcióhoz. Egy példányt a ChatClienten keresztül szerezhet be, és használatával üzeneteket küldhet,fogadhat/frissíthet/törölhet, felhasználókat vehet fel/távolíthat el/kérhet le, gépelési értesítéseket és olvasási visszaigazolásokat küldhet.

Csevegési szál indítása

Ezzel a createThread módszerrel csevegőszálat hozhat létre.

createThreadRequest a szálkérelem leírására szolgál:

Ezzel topic a csevegéssel kapcsolatos témakört adhat meg. A témakörök a függvény használatával UpdateThread történő létrehozása után frissíthetők.
A csevegési szálhoz hozzáadni kívánt résztvevők listázására használható participants .

A feloldáskor a createChatThread metódus egy CreateChatThreadResult. Ez a modell tartalmaz egy tulajdonságot chatThread , amely az újonnan létrehozott szálhoz érhető el id . Ezután a id segítségével lekérheti a példányt ChatThreadClient. Ezután ChatThreadClient a szálon belüli műveletek végrehajtására használható, például üzenetek küldésére vagy résztvevők listázására.

async function createChatThread() {
  const createChatThreadRequest = {
    topic: "Hello, World!"
  };
  const createChatThreadOptions = {
    participants: [
      {
        id: { communicationUserId: '<USER_ID>' },
        displayName: '<USER_DISPLAY_NAME>'
      }
    ]
  };
  const createChatThreadResult = await chatClient.createChatThread(
    createChatThreadRequest,
    createChatThreadOptions
  );
  const threadId = createChatThreadResult.chatThread.id;
  return threadId;
}

createChatThread().then(async threadId => {
  console.log(`Thread created:${threadId}`);
  // PLACEHOLDERS
  // <CREATE CHAT THREAD CLIENT>
  // <RECEIVE A CHAT MESSAGE FROM A CHAT THREAD>
  // <SEND MESSAGE TO A CHAT THREAD>
  // <LIST MESSAGES IN A CHAT THREAD>
  // <ADD NEW PARTICIPANT TO THREAD>
  // <LIST PARTICIPANTS IN A THREAD>
  // <REMOVE PARTICIPANT FROM THREAD>
  });

A böngészőlap frissítésekor a következőnek kell megjelennie a konzolon:

Thread created: <thread_id>

Csevegőszál-ügyfél lekérése

A getChatThreadClient metódus egy chatThreadClient már létező szálat ad vissza. A létrehozott szálon végzett műveletek végrehajtására használható: résztvevők hozzáadása, üzenet küldése stb. A threadId a meglévő csevegési szál egyedi azonosítója.

let chatThreadClient = chatClient.getChatThreadClient(threadId);
console.log(`Chat Thread client for threadId:${threadId}`);

Adja hozzá ezt a kódot a <CREATE CHAT THREAD CLIENT> client.js megjegyzés helyett, frissítse a böngészőlapot, és ellenőrizze a konzolt, a következőt kell látnia:

Chat Thread client for threadId: <threadId>

Az összes csevegési szál listázása

A listChatThreads metódus egy típust PagedAsyncIterableIteratorChatThreadItemad vissza. Az összes csevegési szál listázására használható. A listaszálakból visszaadott válasz iterátora [ChatThreadItem]

const threads = chatClient.listChatThreads();
for await (const thread of threads) {
   // your code here
}

Üzenet küldése csevegési szálra

Ezzel sendMessage a módszerrel üzenetet küldhet a threadId által azonosított szálnak.

sendMessageRequest az üzenetkérelem leírására szolgál:

A csevegőüzenet tartalmának megadására szolgál content ;

sendMessageOptions a művelet opcionális paramjeinek leírására szolgál:

A feladó megjelenítendő nevének megadására használható senderDisplayName ;
Az üzenet típusának megadására szolgál type , például "szöveg" vagy "html";
Tetszés metadata szerint használhatja az üzenettel együtt elküldeni kívánt egyéb adatokat is. Ez a mező egy mechanizmust biztosít a fejlesztőknek a csevegőüzenetek funkcióinak kibővítésére és a használati esethez tartozó egyéni információk hozzáadására. Ha például megoszt egy fájlhivatkozást az üzenetben, érdemes lehet "hasAttachment: true" értéket hozzáadni a metaadatokhoz, hogy a címzett alkalmazása elemezhesse és ennek megfelelően jelenjen meg.

SendChatMessageResult az üzenet küldésével visszaadott válasz, amely egy azonosítót tartalmaz, amely az üzenet egyedi azonosítója.

const sendMessageRequest =
{
  content: 'Please take a look at the attachment'
};
let sendMessageOptions =
{
  senderDisplayName : 'Jack',
  type: 'text',
  metadata: {
    'hasAttachment': 'true',
    'attachmentUrl': 'https://contoso.com/files/attachment.docx'
  }
};
const sendChatMessageResult = await chatThreadClient.sendMessage(sendMessageRequest, sendMessageOptions);
const messageId = sendChatMessageResult.id;
console.log(`Message sent!, message id:${messageId}`);

Adja hozzá ezt a kódot a <SEND MESSAGE TO A CHAT THREAD> client.js megjegyzés helyett, frissítse a böngészőlapot, és ellenőrizze a konzolt.

Message sent!, message id:<number>

Csevegőüzenetek fogadása csevegőszálból

Valós idejű jelzéssel előfizethet az új bejövő üzenetek figyelésére, és ennek megfelelően frissítheti az aktuális üzeneteket a memóriában. Az Azure Communication Services támogatja azoknak az eseményeknek a listáját, amelyekre előfizethet.

// open notifications channel
await chatClient.startRealtimeNotifications();
// subscribe to new notification
chatClient.on("chatMessageReceived", (e) => {
  console.log("Notification chatMessageReceived!");
  // your code here
});

Adja hozzá ezt a kódot megjegyzés helyett a <RECEIVE A CHAT MESSAGE FROM A CHAT THREAD> client.js fájlban. Frissítse a böngészőlapot, a konzolon egy üzenetnek Notification chatMessageReceivedkell megjelennie;

Másik lehetőségként lekérheti a csevegőüzeneteket a listMessages metódus megadott időközönkénti lekérdezésével.


const messages = chatThreadClient.listMessages();
for await (const message of messages) {
   // your code here
}

Adja hozzá ezt a kódot a <LIST MESSAGES IN A CHAT THREAD> client.js megjegyzés helyett. Frissítse a lapot, a konzolon keresse meg az ebben a csevegési szálban küldött üzenetek listáját.

listMessagesA különböző típusú üzeneteket ad vissza, amelyek azonosíthatók.chatMessage.type

További részletekért lásd : Üzenettípusok.

Felhasználó hozzáadása résztvevőként a csevegési szálhoz

A metódus meghívása addParticipants előtt győződjön meg arról, hogy új hozzáférési jogkivonatot és identitást szerzett be a felhasználó számára. A felhasználónak szüksége lesz erre a hozzáférési jogkivonatra a csevegőügyfél inicializálásához.

addParticipantsRequest azt a kérésobjektumot írja le, amely participants felsorolja a csevegési szálhoz hozzáadni kívánt résztvevőket;

id, kötelező, az a kommunikációs azonosító, amelyet hozzá kell adni a csevegési szálhoz.
displayName, nem kötelező, a szál résztvevőjének megjelenítendő neve.
shareHistoryTime, nem kötelező, az az idő, amikor a csevegési előzmények meg lesznek osztva a résztvevővel. Ha meg szeretné osztani az előzményeket a csevegési szál kezdete óta, állítsa ezt a tulajdonságot a szál létrehozásának időpontjánál egyenlő vagy annál rövidebb dátumra. Ha nem szeretne korábbi előzményeket megosztani a résztvevő hozzáadásakor, állítsa be az aktuális dátumra. A részleges előzmények megosztásához állítsa be a kívánt dátumra.


const addParticipantsRequest =
{
  participants: [
    {
      id: { communicationUserId: '<NEW_PARTICIPANT_USER_ID>' },
      displayName: 'Jane'
    }
  ]
};

await chatThreadClient.addParticipants(addParticipantsRequest);

Cserélje le a NEW_PARTICIPANT_UStandard kiadásR_ID egy új felhasználói azonosítóra: Adja hozzá ezt a kódot a <ADD NEW PARTICIPANT TO THREAD> client.js megjegyzés helyett

Felhasználók listázása csevegési szálon

const participants = chatThreadClient.listParticipants();
for await (const participant of participants) {
   // your code here
}

Adja hozzá ezt a kódot a <LIST PARTICIPANTS IN A THREAD> client.js megjegyzése helyett, frissítse a böngészőlapot, és ellenőrizze a konzolt, és látnia kell egy szál felhasználóinak adatait.

Felhasználó eltávolítása csevegőszálból

A résztvevők hozzáadásához hasonlóan eltávolíthatja a résztvevőket egy csevegési szálból. Az eltávolításhoz nyomon kell követnie a hozzáadott résztvevők azonosítóit.

Használja removeParticipant azt a metódust, amelyben participant a kommunikációs felhasználót el kell távolítani a szálból.


await chatThreadClient.removeParticipant({ communicationUserId: <PARTICIPANT_ID> });
await listParticipants();

Cserélje le PARTICIPANT_ID az előző lépésben (<NEW_PARTICIPANT_UStandard kiadásR_ID>) használt felhasználói azonosítóra. Adja hozzá ezt a kódot a <REMOVE PARTICIPANT FROM THREAD> client.js megjegyzés helyett.

Előfizetés eseményekhez realTimeNotificationConnected , és realTimeNotificationDisconnected lehetővé teszi, hogy megtudja, mikor aktív a kapcsolat a híváskiszolgálóval.

// subscribe to realTimeNotificationConnected event
chatClient.on('realTimeNotificationConnected', () => {
  console.log("Real time notification is now connected!");
  // your code here
});
// subscribe to realTimeNotificationDisconnected event
chatClient.on('realTimeNotificationDisconnected', () => {
  console.log("Real time notification is now disconnected!");
  // your code here
});

Mintakód

Keresse meg a gitHubon a rövid útmutató véglegesített kódját.

Előfeltételek

Az első lépések előtt győződjön meg arról, hogy:

Azure-fiók létrehozása aktív előfizetéssel. További részletekért lásd : Fiók létrehozása ingyenesen.
Telepítse a Python 3.7+-ot.
Hozzon létre egy Azure Communication Services-erőforrást. További részletekért tekintse meg a Communication Services-erőforrások létrehozását és kezelését ismertető rövid útmutatót. Ehhez a rövid útmutatóhoz rögzítenie kell az erőforrásvégpontot és a kapcsolati sztring.
Felhasználói hozzáférési jogkivonat. Ügyeljen arra, hogy a hatókört csevegésre állítsa, és jegyezze fel a jogkivonat sztringet, valamint a user_id sztringet. Az Azure CLI használatával az alábbi parancsot is futtathatja a kapcsolati sztring egy felhasználó és egy hozzáférési jogkivonat létrehozásához.
```
az communication identity token issue --scope chat --connection-string "yourConnectionString"
```
További részletekért lásd: Hozzáférési jogkivonatok létrehozása és kezelése az Azure CLI használatával.

Beállítás

Új Python-alkalmazás létrehozása

Nyissa meg a terminált vagy a parancsablakot, hozzon létre egy új könyvtárat az alkalmazáshoz, és nyissa meg.

mkdir chat-quickstart && cd chat-quickstart

Szövegszerkesztővel hozzon létre egy start-chat.py nevű fájlt a projekt gyökérkönyvtárában. Adja hozzá a program struktúráját, beleértve az alapvető kivételkezelést is. A következő szakaszokban a rövid útmutató összes forráskódját hozzáadja ehhez a fájlhoz.

import os
# Add required SDK components from quickstart here

try:
    print('Azure Communication Services - Chat Quickstart')
    # Quickstart code goes here
except Exception as ex:
    print('Exception:')
    print(ex)

Az SDK telepítése

Az SDK telepítéséhez használja a következő parancsot:


pip install azure-communication-chat

Objektummodell

Az alábbi osztályok és felületek kezelik a Pythonhoz készült Azure Communication Services Chat SDK főbb funkcióit.

Name	Leírás
`ChatClient`	Ez az osztály szükséges a csevegési funkcióhoz. Az előfizetés adataival példányosíthatja azokat, és szálak létrehozására, lekérésére és törlésére használhatja őket.
`ChatThreadClient`	Ez az osztály szükséges a csevegési szál működéséhez. A példányt az üzenetküldés, fogadás, frissítés és törlés útján `ChatClient`szerezheti be, és használhatja azt. Emellett felhasználók hozzáadására, eltávolítására és lekérésére, valamint gépelési értesítések és olvasási visszaigazolások küldésére is használható.

Csevegőügyfél létrehozása

Csevegőügyfél létrehozásához használja a Communication Services-végpontot és a létrehozott hozzáférési jogkivonatot az előfeltételek lépéseinek részeként.

pip install azure-communication-identity

from azure.communication.chat import ChatClient, CommunicationTokenCredential

endpoint = "<replace with your resource endpoint>"
chat_client = ChatClient(endpoint, CommunicationTokenCredential("<Access Token>"))

Ez a rövid útmutató nem foglalja magában a szolgáltatásszint létrehozását a csevegőalkalmazás jogkivonatainak kezeléséhez, de ez ajánlott. További információkért tekintse meg a csevegési fogalmak "Csevegési architektúra" című szakaszát.

Csevegési szál indítása

Ezzel a create_chat_thread módszerrel csevegőszálat hozhat létre.

A téma témájának adására használható topic . A témakört a csevegési szál a függvény használatával update_thread történő létrehozása után frissítheti.
A csevegőszálhoz hozzáadandó lista listázására ChatParticipant használhatóthread_participants. A ChatParticipant típust a CommunicationUserIdentifier következőként userveszi fel: .

CreateChatThreadResult a szál létrehozásakor visszaadott eredmény. Ezzel lekérheti a id létrehozott csevegési szálat. Ezzel id a módszerrel lekérhet egy ChatThreadClient objektumot get_chat_thread_client . Ezzel a csevegési szállal más csevegési műveleteket is végrehajthat ChatThreadClient .

topic="test topic"

create_chat_thread_result = chat_client.create_chat_thread(topic)
chat_thread_client = chat_client.get_chat_thread_client(create_chat_thread_result.chat_thread.id)

Csevegőszál-ügyfél lekérése

A get_chat_thread_client metódus egy már létező szálügyfélt ad vissza. Használatával műveleteket hajthat végre a létrehozott szálon. Felvehet például résztvevőket, és üzeneteket küldhet. thread_id A meglévő csevegési szál egyedi azonosítója.

Ezzel a csevegési szállal más csevegési műveleteket is végrehajthat ChatThreadClient .

thread_id = create_chat_thread_result.chat_thread.id
chat_thread_client = chat_client.get_chat_thread_client(thread_id)

Az összes csevegési szál listázása

A list_chat_threads metódus egy típusú ChatThreadItemiterátort ad vissza.

A csevegési szálak lekérésének legkorábbi időpontjának megadására használható start_time .
Az oldalonként visszaadott csevegési szálak maximális számának megadására használható results_per_page .

A listaszálakból visszaadott válasz iterátora [ChatThreadItem] .

from datetime import datetime, timedelta

start_time = datetime.utcnow() - timedelta(days=2)

chat_threads = chat_client.list_chat_threads(results_per_page=5, start_time=start_time)
for chat_thread_item_page in chat_threads.by_page():
    for chat_thread_item in chat_thread_item_page:
        print(chat_thread_item)
        print('Chat Thread Id: ', chat_thread_item.id)

Üzenet küldése csevegési szálra

Ezzel a send_message módszerrel üzenetet küldhet az imént létrehozott csevegőszálnak, amelyet thread_ida rendszer azonosított.

A csevegőüzenet tartalmának megadására szolgál content .
Az üzenet tartalomtípusának megadására használható chat_message_type . A lehetséges értékek a következők: text és html. Ha nem ad meg értéket, az alapértelmezett érték a következő text.
A feladó megjelenítendő nevének megadására használható sender_display_name .
Ha metadata szeretné, az üzenettel együtt további adatokat is megadhat. Ez a mező egy mechanizmust biztosít a fejlesztőknek a csevegőüzenetek funkcióinak kibővítésére és a használati esethez tartozó egyéni információk hozzáadására. Ha például megoszt egy fájlhivatkozást az üzenetben, érdemes lehet "hasAttachment:true" értéket hozzáadni a metaadatokhoz, hogy a címzett alkalmazása elemezhesse és ennek megfelelően jelenjen meg.

SendChatMessageResult az üzenet küldéséből visszaadott válasz. Egy azonosítót tartalmaz, amely az üzenet egyedi azonosítója.

from azure.communication.chat import ChatMessageType

topic = "test topic"
create_chat_thread_result = chat_client.create_chat_thread(topic)
thread_id = create_chat_thread_result.chat_thread.id
chat_thread_client = chat_client.get_chat_thread_client(create_chat_thread_result.chat_thread.id)


content='Please take a look at the attachment'
sender_display_name='sender name'
metadata={
    'hasAttachment': 'true',
    'attachmentUrl': 'https://contoso.com/files/attachment.docx'
}

# specify chat message type with pre-built enumerations
send_message_result_w_enum = chat_thread_client.send_message(content=content, sender_display_name=sender_display_name, chat_message_type=ChatMessageType.TEXT, metadata=metadata)
print("Message sent: id: ", send_message_result_w_enum.id)

Csevegőüzenetek fogadása csevegőszálból

A csevegőüzenetek lekéréséhez a metódust list_messages meghatározott időközönként kell lekérdezni.

A results_per_page visszaadandó üzenetek maximális számát adja meg oldalanként.
Itt start_time adhatja meg az üzenetek lekérésének legkorábbi időpontját.

A listaüzenetekből visszaadott válasz iterátora [ChatMessage] .

from datetime import datetime, timedelta

start_time = datetime.utcnow() - timedelta(days=1)

chat_messages = chat_thread_client.list_messages(results_per_page=1, start_time=start_time)
for chat_message_page in chat_messages.by_page():
    for chat_message in chat_message_page:
        print("ChatMessage: Id=", chat_message.id, "; Content=", chat_message.content.message)

list_messages Az üzenet legújabb verzióját adja vissza, beleértve az üzenet használatával és használatával update_message történt módosításokat és delete_messagetörléseket is. Törölt üzenetek ChatMessage.deleted_on esetén az datetime üzenet törlésének időpontját jelző értéket ad vissza. Szerkesztett üzenetek esetén egy datetime értéket ad vissza, ChatMessage.edited_on amely jelzi, hogy mikor lett szerkesztve az üzenet. Az üzenetlétrehozás ChatMessage.created_oneredeti időpontját az üzenetek megrendeléséhez használható használatával érheti el.

list_messages különböző típusú üzeneteket ad vissza, amelyek azonosíthatók a ChatMessage.type.

További információ: Üzenettípusok.

Olvasási visszaigazolás küldése

Ezzel a send_read_receipt módszerrel olvasási visszaigazolási eseményt tehet közzé egy szálon egy felhasználó nevében.

Az aktuális felhasználó által beolvasott legújabb üzenet azonosítójának megadására szolgál message_id .

content='hello world'

send_message_result = chat_thread_client.send_message(content)
chat_thread_client.send_read_receipt(message_id=send_message_result.id)

Felhasználó hozzáadása résztvevőként a csevegési szálhoz

Csevegési szál létrehozásakor felhasználókat vehet fel és távolíthat el belőle. A felhasználók hozzáadásával hozzáférést adhat nekik ahhoz, hogy üzeneteket tudjanak küldeni a csevegési szálra, és más résztvevőket vegyenek fel vagy távolíthassanak el. A metódus meghívása add_participants előtt győződjön meg arról, hogy új hozzáférési jogkivonatot és identitást szerzett be a felhasználó számára. A felhasználónak szüksége van erre a hozzáférési jogkivonatra a csevegőügyfél inicializálásához.

A módszer használatával hozzáadhat egy vagy több felhasználót a add_participants csevegési szálhoz, feltéve, hogy minden felhasználó számára elérhető egy új hozzáférési jogkivonat és identitás.

A list(tuple(ChatParticipant, CommunicationError)) visszaadott érték. A résztvevő sikeres hozzáadása után üres lista várható. Ha egy résztvevő hozzáadásakor hiba lép fel, a rendszer feltölti a listát a sikertelen résztvevőkkel, valamint a tapasztalt hibával.

from azure.communication.identity import CommunicationIdentityClient
from azure.communication.chat import ChatParticipant
from datetime import datetime

# create 2 users
identity_client = CommunicationIdentityClient.from_connection_string('<connection_string>')
new_users = [identity_client.create_user() for i in range(2)]

# # conversely, you can also add an existing user to a chat thread; provided the user_id is known
# from azure.communication.identity import CommunicationUserIdentifier
#
# user_id = 'some user id'
# user_display_name = "Wilma Flinstone"
# new_user = CommunicationUserIdentifier(user_id)
# participant = ChatParticipant(
#     identifier=new_user,
#     display_name=user_display_name,
#     share_history_time=datetime.utcnow())

participants = []
for _user in new_users:
  chat_thread_participant = ChatParticipant(
    identifier=_user,
    display_name='Fred Flinstone',
    share_history_time=datetime.utcnow()
  ) 
  participants.append(chat_thread_participant) 

response = chat_thread_client.add_participants(participants)

def decide_to_retry(error, **kwargs):
    """
    Insert some custom logic to decide if retry is applicable based on error
    """
    return True

# verify if all users has been successfully added or not
# in case of partial failures, you can retry to add all the failed participants 
retry = [p for p, e in response if decide_to_retry(e)]
if retry:
    chat_thread_client.add_participants(retry)

Csevegési szál résztvevőinek listázása

A résztvevők hozzáadásához hasonlóan a résztvevőket egy szálból is listázhatja.

A szál résztvevőinek lekérésére használható list_participants . Az alábbi parancsok egyike nem kötelező:

Itt results_per_page adhatja meg, hogy hány résztvevőt kell visszaadni oldalanként.
A skip résztvevőket a válaszban megadott pozícióba ugorhatja.

Az iterátor a [ChatParticipant] résztvevők listázásából kapott válasz.

chat_thread_participants = chat_thread_client.list_participants()
for chat_thread_participant_page in chat_thread_participants.by_page():
    for chat_thread_participant in chat_thread_participant_page:
        print("ChatParticipant: ", chat_thread_participant)

A kód futtatása

Futtassa az alkalmazást az alkalmazáskönyvtárból a python paranccsal.

python start-chat.py

Mintakód

Keresse meg a gitHubon a rövid útmutató véglegesített kódját.

Előfeltételek

Egy Azure-fiók, aktív előfizetéssel. Fiók ingyenes létrehozása.
A Java Development Kit (JDK) 8- vagy újabb verziója.
Apache Maven.
Hozzon létre egy Azure Communication Services-erőforrást. További részletekért lásd : Azure Communication Services-erőforrás létrehozása. Ehhez a rövid útmutatóhoz rögzítenie kell az erőforrásvégpontot és a kapcsolati sztring.
Felhasználói hozzáférési jogkivonat. Ügyeljen arra, hogy a hatókört csevegésre állítsa, és jegyezze fel a jogkivonat sztringet, valamint a user_id sztringet. Az Azure CLI használatával az alábbi parancsot is futtathatja a kapcsolati sztring egy felhasználó és egy hozzáférési jogkivonat létrehozásához.
```
az communication identity token issue --scope chat --connection-string "yourConnectionString"
```
További részletekért lásd: Hozzáférési jogkivonatok létrehozása és kezelése az Azure CLI használatával.

Beállítás

Új Java-alkalmazás létrehozása

Nyissa meg a terminált vagy a parancsablakot, és lépjen arra a könyvtárra, ahol létre szeretné hozni a Java-alkalmazást. Futtassa az alábbi parancsot a Java-projekt létrehozásához a maven-archetype-quickstart sablonból.

mvn archetype:generate -DgroupId=com.communication.quickstart -DartifactId=communication-quickstart -DarchetypeArtifactId=maven-archetype-quickstart -DarchetypeVersion=1.4 -DinteractiveMode=false

Megfigyelheti, hogy a "létrehozás" cél egy olyan könyvtárat hozott létre, amelynek a neve megegyezik az artifactId azonosítójával. Ebben a könyvtárban a src/main/java directory projekt forráskódja, a src/test/java könyvtár a tesztforrást, a pom.xml fájl pedig a projekt projektobjektum-modelljét vagy POM-ját tartalmazza.

Frissítse az alkalmazás POM-fájlját a Java 8 vagy újabb verziójára:

<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
</properties>

A csevegő SDK csomaghivatkozásainak hozzáadása

A POM-fájlban hivatkozzon a azure-communication-chat csomagra a Csevegés API-kkal:

<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-communication-chat</artifactId>
    <version><!-- Please refer to https://search.maven.org/artifact/com.azure/azure-communication-chat for the latest version --></version>
</dependency>

A hitelesítéshez az ügyfélnek a csomagra kell hivatkoznia azure-communication-common :

<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-communication-common</artifactId>
    <version><!-- Please refer to https://search.maven.org/artifact/com.azure/azure-communication-common for the latest version --></version>
</dependency>

Objektummodell

Az alábbi osztályok és felületek kezelik a Java-hoz készült Azure Communication Services Chat SDK főbb funkcióit.

Name	Leírás
ChatClient	Ez az osztály a Csevegés funkcióhoz szükséges. Példányosíthatja az előfizetés adataival, és szálak létrehozására, lekérésére és törlésére használhatja őket.
ChatAsyncClient	Ez az osztály az aszinkron csevegési funkcióhoz szükséges. Példányosíthatja az előfizetés adataival, és szálak létrehozására, lekérésére és törlésére használhatja őket.
ChatThreadClient	Ez az osztály szükséges a Csevegési szál funkcióhoz. Egy példányt a ChatClienten keresztül szerezhet be, és használatával üzeneteket küldhet,fogadhat/frissíthet/törölhet, felhasználókat vehet fel/távolíthat el/kérhet le, gépelési értesítéseket és olvasási visszaigazolásokat küldhet.
ChatThreadAsyncClient	Ez az osztály az aszinkron csevegési szál működéséhez szükséges. Egy példányt a ChatAsyncClienten keresztül szerezhet be, és használatával üzeneteket küldhet,fogadhat/frissíthet/törölhet, felhasználókat vehet fel/távolíthat el/kérhet le, gépelési értesítéseket és olvasási visszaigazolásokat küldhet.

Csevegőügyfél létrehozása

Csevegőügyfél létrehozásához a Kommunikációs szolgáltatás végpontját és a szükséges lépések részeként létrehozott hozzáférési jogkivonatot fogja használni. A felhasználói hozzáférési jogkivonatok lehetővé teszik olyan ügyfélalkalmazások létrehozását, amelyek közvetlenül hitelesítik magukat az Azure Communication Servicesben. Miután létrehozta ezeket a jogkivonatokat a kiszolgálón, továbbítsa őket egy ügyféleszközre. A jogkivonat csevegőügyfélnek való átadásához a Common SDK CommunicationTokenCredential osztályát kell használnia.

További információ a csevegési architektúráról

Az importálási utasítások hozzáadásakor ügyeljen arra, hogy csak a com.azure.communication.chat és com.azure.communication.chat.models névterekből adjon hozzá importálásokat, és ne a com.azure.communication.chat.implementációs névtérből. A Mavenen keresztül létrehozott App.java fájlban a következő kóddal kezdheti:

package com.communication.quickstart;

import com.azure.communication.chat.*;
import com.azure.communication.chat.models.*;
import com.azure.communication.common.*;
import com.azure.core.http.rest.PagedIterable;

import java.io.*;
import java.util.*;

public class App
{
    public static void main( String[] args ) throws IOException
    {
        System.out.println("Azure Communication Services - Chat Quickstart");

        // Your unique Azure Communication service endpoint
        String endpoint = "<replace with your resource endpoint>";

        // User access token fetched from your trusted service
        String userAccessToken = "<USER_ACCESS_TOKEN>";

        // Create a CommunicationTokenCredential with the given access token, which is only valid until the token is valid
        CommunicationTokenCredential userCredential = new CommunicationTokenCredential(userAccessToken);

        // Initialize the chat client
        final ChatClientBuilder builder = new ChatClientBuilder();
        builder.endpoint(endpoint)
            .credential(userCredential);
        ChatClient chatClient = builder.buildClient();
    }
}

Csevegési szál indítása

Ezzel a createChatThread módszerrel csevegőszálat hozhat létre. createChatThreadOptions a szálkérelem leírására szolgál.

topic A konstruktor paraméterével adjon egy témakört a csevegéshez; A témakör akkor frissíthető, ha a csevegőszál a UpdateThread függvény használatával jött létre.
A participants szál résztvevőinek listázásához használja a szálhoz hozzáadni kívánt résztvevőket. ChatParticipanta felhasználói hozzáférési jogkivonat gyorsútmutatójában létrehozott felhasználót veszi át.

CreateChatThreadResult a csevegési szál létrehozásakor visszaadott válasz. Tartalmaz egy metódust getChatThread() , amely visszaadja azt az ChatThread objektumot, amely a szálügyfél lekéréséhez használható, amelyből lekérheti a ChatThreadClient létrehozott szálon végzett műveletek végrehajtását: résztvevők hozzáadása, üzenet küldése stb. Az ChatThread objektum tartalmazza a metódust getId() is, amely lekéri a szál egyedi azonosítóját.

CommunicationUserIdentifier identity1 = new CommunicationUserIdentifier("<USER_1_ID>");
CommunicationUserIdentifier identity2 = new CommunicationUserIdentifier("<USER_2_ID>");

ChatParticipant firstThreadParticipant = new ChatParticipant()
    .setCommunicationIdentifier(identity1)
    .setDisplayName("Participant Display Name 1");

ChatParticipant secondThreadParticipant = new ChatParticipant()
    .setCommunicationIdentifier(identity2)
    .setDisplayName("Participant Display Name 2");

CreateChatThreadOptions createChatThreadOptions = new CreateChatThreadOptions("Topic")
    .addParticipant(firstThreadParticipant)
    .addParticipant(secondThreadParticipant);

CreateChatThreadResult result = chatClient.createChatThread(createChatThreadOptions);
String chatThreadId = result.getChatThread().getId();

Csevegési szálak listázása

A metódussal listChatThreads lekérheti a meglévő csevegési szálak listáját.

PagedIterable<ChatThreadItem> chatThreads = chatClient.listChatThreads();

chatThreads.forEach(chatThread -> {
    System.out.printf("ChatThread id is %s.\n", chatThread.getId());
});

Csevegőszál-ügyfél lekérése

A getChatThreadClient metódus egy már létező szálügyfélt ad vissza. A létrehozott szálon végzett műveletek végrehajtásához használható: résztvevők hozzáadása, üzenet küldése stb. chatThreadId A meglévő csevegési szál egyedi azonosítója.

ChatThreadClient chatThreadClient = chatClient.getChatThreadClient(chatThreadId);

Üzenet küldése csevegési szálra

Ezzel a sendMessage módszerrel üzenetet küldhet a létrehozott szálnak, amelyet a chatThreadId azonosít. sendChatMessageOptions a csevegőüzenet-kérés leírására szolgál.

A csevegőüzenet tartalmának megadására szolgál content .
A csevegőüzenet tartalomtípusának, szövegének vagy HTML-jének megadására használható type .
A feladó megjelenítendő nevének megadására használható senderDisplayName .
Ha metadata szeretné, az üzenettel együtt további adatokat is megadhat. Ez a mező egy mechanizmust biztosít a fejlesztőknek a csevegőüzenetek funkcióinak kibővítésére és a használati esethez tartozó egyéni információk hozzáadására. Ha például megoszt egy fájlhivatkozást az üzenetben, érdemes lehet metaadatokat hozzáadni hasAttachment:true , hogy a címzett alkalmazása elemezhesse és ennek megfelelően jelenjen meg.

A válasz sendChatMessageResult tartalmaz egy id, amely az üzenet egyedi azonosítója.

Map<String, String> metadata = new HashMap<String, String>();
metadata.put("hasAttachment", "true");
metadata.put("attachmentUrl", "https://contoso.com/files/attachment.docx");

SendChatMessageOptions sendChatMessageOptions = new SendChatMessageOptions()
    .setContent("Please take a look at the attachment")
    .setType(ChatMessageType.TEXT)
    .setSenderDisplayName("Sender Display Name")
    .setMetadata(metadata);

SendChatMessageResult sendChatMessageResult = chatThreadClient.sendMessage(sendChatMessageOptions);
String chatMessageId = sendChatMessageResult.getId();

Csevegőüzenetek fogadása csevegőszálból

A csevegőüzenetek lekéréséhez lekérdezheti a listMessages metódust a csevegőszál-ügyfélen megadott időközönként.

chatThreadClient.listMessages().forEach(message -> {
    System.out.printf("Message id is %s.\n", message.getId());
});

listMessages Az üzenet legújabb verzióját adja vissza, beleértve az üzenet .editMessage() használatával és használatával történt módosításokat és .deleteMessage()törléseket is. Törölt üzenetek esetén egy dátum/idő értéket ad vissza, chatMessage.getDeletedOn() amely jelzi az üzenet törlésének időpontját. Szerkesztett üzenetek esetén egy dátumidőt ad vissza, chatMessage.getEditedOn() amely jelzi, hogy mikor lett szerkesztve az üzenet. Az üzenetlétrehozás eredeti időpontja a következővel chatMessage.getCreatedOn()érhető el, és az üzenetek megrendeléséhez használható.

Az üzenettípusokról itt olvashat bővebben: Üzenettípusok.

Olvasási visszaigazolás küldése

Ezzel a sendReadReceipt módszerrel egy felhasználó nevében közzétehet egy olvasási visszaigazolási eseményt egy csevegési szálon. chatMessageId az olvasott csevegőüzenet egyedi azonosítója.

String chatMessageId = message.getId();
chatThreadClient.sendReadReceipt(chatMessageId);

Csevegés résztvevőinek listázása

A chatThreadId által azonosított csevegési szál résztvevőit tartalmazó lapozott gyűjtemény lekérésére használható listParticipants .

PagedIterable<ChatParticipant> chatParticipantsResponse = chatThreadClient.listParticipants();
chatParticipantsResponse.forEach(chatParticipant -> {
    System.out.printf("Participant id is %s.\n", ((CommunicationUserIdentifier) chatParticipant.getCommunicationIdentifier()).getId());
});

Felhasználó hozzáadása résztvevőként a csevegési szálhoz

Miután létrehozott egy csevegési szálat, hozzáadhat és eltávolíthat belőle felhasználókat. Felhasználók hozzáadásával hozzáférést adhat nekik, hogy üzeneteket küldjenek a csevegési szálra, és más résztvevőket is hozzáadhatnak/eltávolíthat. Először le kell kérnie egy új hozzáférési jogkivonatot és identitást az adott felhasználóhoz. Mielőtt meghívja az AddParticipants metódust, győződjön meg arról, hogy új hozzáférési jogkivonatot és identitást szerzett be a felhasználó számára. A felhasználónak szüksége lesz erre a hozzáférési jogkivonatra a csevegőügyfél inicializálásához.

Ezzel a addParticipants módszerrel adhat hozzá résztvevőket a szálhoz.

communicationIdentifier, kötelező, az a CommunicationIdentifier, amelyet a CommunicationIdentityClient hozott létre a felhasználói hozzáférési jogkivonat gyorsútmutatójában.
displayName, nem kötelező, a szál résztvevőjének megjelenítendő neve.
shareHistoryTime, nem kötelező, az az idő, amikor a csevegési előzmények meg lesznek osztva a résztvevővel. Ha meg szeretné osztani az előzményeket a csevegési szál kezdete óta, állítsa ezt a tulajdonságot a szál létrehozásának időpontjánál egyenlő vagy annál rövidebb dátumra. Ha nem szeretne korábbi előzményeket megosztani a résztvevő hozzáadásakor, állítsa be az aktuális dátumra. A részleges előzmények megosztásához állítsa be a kívánt dátumra.

List<ChatParticipant> participants = new ArrayList<ChatParticipant>();

CommunicationUserIdentifier identity3 = new CommunicationUserIdentifier("<USER_3_ID>");
CommunicationUserIdentifier identity4 = new CommunicationUserIdentifier("<USER_4_ID>");

ChatParticipant thirdThreadParticipant = new ChatParticipant()
    .setCommunicationIdentifier(identity3)
    .setDisplayName("Display Name 3");

ChatParticipant fourthThreadParticipant = new ChatParticipant()
    .setCommunicationIdentifier(identity4)
    .setDisplayName("Display Name 4");

participants.add(thirdThreadParticipant);
participants.add(fourthThreadParticipant);

chatThreadClient.addParticipants(participants);

A kód futtatása

Lépjen a pom.xml fájlt tartalmazó könyvtárra, és fordítsa le a projektet az alábbi mvn paranccsal.

mvn compile

Ezután hozza létre a csomagot.

mvn package

Futtassa a következő mvn parancsot az alkalmazás végrehajtásához.

mvn exec:java -Dexec.mainClass="com.communication.quickstart.App" -Dexec.cleanupDaemonThreads=false

Mintakód

Keresse meg a gitHubon a rövid útmutató véglegesített kódját.

Előfeltételek

Az első lépések előtt győződjön meg arról, hogy:

Azure-fiók létrehozása aktív előfizetéssel. További részletekért lásd : Fiók létrehozása ingyenesen.
Telepítse az Android Studiót, az Android Studio használatával hozunk létre egy Android-alkalmazást a függőségek telepítéséhez szükséges rövid útmutatóhoz.
Hozzon létre egy Azure Communication Services-erőforrást. További részletekért lásd : Azure Communication Services-erőforrás létrehozása. Ehhez a rövid útmutatóhoz rögzítenie kell az erőforrásvégpontot és a kapcsolati sztring.
Hozzon létre két Communication Services-felhasználót, és adjon ki nekik egy felhasználói hozzáférési jogkivonatot. Ügyeljen arra, hogy a hatókört csevegésre állítsa, és jegyezze fel a jogkivonat sztringet és a user_id sztringet. Ebben a rövid útmutatóban létrehozunk egy szálat egy kezdeti résztvevővel, majd hozzáadunk egy második résztvevőt a szálhoz. Az Azure CLI használatával az alábbi parancsot is futtathatja a kapcsolati sztring egy felhasználó és egy hozzáférési jogkivonat létrehozásához.
```
az communication identity token issue --scope chat --connection-string "yourConnectionString"
```
További részletekért lásd: Hozzáférési jogkivonatok létrehozása és kezelése az Azure CLI használatával.

Beállítás

Új androidos alkalmazás létrehozása

Nyissa meg az Android Studiót, és válassza a lehetőséget Create a new project.
A következő ablakban válassza ki Empty Activity a projektsablont.
A beállítások kiválasztásakor adja meg ChatQuickstart a projekt nevét.
Kattintson a tovább gombra, és válassza ki azt a könyvtárat, amelyben létre szeretné hozni a projektet.

A kódtárak telepítése

A Gradle használatával telepítjük a szükséges Communication Services-függőségeket. A parancssorból navigáljon a projekt gyökérkönyvtárában ChatQuickstart . Nyissa meg az alkalmazás build.gradle fájlját, és adja hozzá a következő függőségeket a ChatQuickstart célhoz:

implementation 'com.azure.android:azure-communication-common:' + $azureCommunicationCommonVersion
implementation 'com.azure.android:azure-communication-chat:' + $azureCommunicationChatVersion
implementation 'org.slf4j:slf4j-log4j12:1.7.29'

Tekintse meg https://search.maven.org/artifact/com.azure.android/azure-communication-common és https://search.maven.org/artifact/com.azure.android/azure-communication-chat keresse meg a legújabb verziószámokat.

Metafájlok kizárása a root build.gradle csomagolási beállításaiban

android {
   ...
    packagingOptions {
        exclude 'META-INF/DEPENDENCIES'
        exclude 'META-INF/LICENSE'
        exclude 'META-INF/license'
        exclude 'META-INF/NOTICE'
        exclude 'META-INF/notice'
        exclude 'META-INF/ASL2.0'
        exclude("META-INF/*.md")
        exclude("META-INF/*.txt")
        exclude("META-INF/*.kotlin_module")
    }
}

(Alternatív) Kódtárak telepítése a Mavenen keresztül

Ha a Maven buildrendszerrel szeretné importálni a tárat a projektbe, adja hozzá az dependencies alkalmazás pom.xml fájljának szakaszához, megadva annak összetevő-azonosítóját és a használni kívánt verziót:

<dependency>
  <groupId>com.azure.android</groupId>
  <artifactId>azure-communication-chat</artifactId>
  <version><!-- Please refer to https://search.maven.org/artifact/com.azure.android/azure-communication-chat for the latest version --></version>
</dependency>

Azure-függvény beállítása

A részletekért tekintse meg az Azure-függvények integrációját . Erősen javasoljuk, hogy integráljon az Azure-függvényrel a szigorú kódolású alkalmazásparaméterek elkerülése érdekében.

Alkalmazásállandók beállítása:

Hozzon létre egy osztályt ApplicationConstants , amely az összes alkalmazásállandót tárolja:

public class ApplicationConstants {
    public static final String SDK_VERSION = "<your_version>";
    public final static String SDK_NAME = "azure-communication-com.azure.android.communication.chat";
    public final static String APPLICATION_ID = "Chat_Test_App";
    public final static String TAG = "[Chat Test App]";
    public static CommunicationTokenCredential COMMUNICATION_TOKEN_CREDENTIAL;
}

A helyőrzők beállítása

Nyissa meg és szerkessze a fájlt MainActivity.java. Ebben a rövid útmutatóban hozzáadjuk a kódot a konzolhoz MainActivity, és megtekintjük a kimenetet. Ez a gyors üzembe helyezés nem foglalkozik a felhasználói felület létrehozásával. A fájl tetején importálja a Azure Communication Common, Azure Communication Chatés más rendszertárakat:

import com.azure.android.communication.chat.*;
import com.azure.android.communication.chat.models.*;
import com.azure.android.communication.common.*;

import android.os.Bundle;
import android.util.Log;
import android.widget.Toast;

import com.jakewharton.threetenabp.AndroidThreeTen;

import java.util.ArrayList;
import java.util.List;

Másolja a következő kódot a fájl MainActivity.javaosztályábaMainActivity:

    private ChatAsyncClient chatAsyncClient;

    private void log(String msg) {
        Log.i(TAG, msg);
        Toast.makeText(this, msg, Toast.LENGTH_LONG).show();
    }
    
   @Override
    protected void onStart() {
        super.onStart();
        try {
            AndroidThreeTen.init(this);

            // Initialize application parameters if one of the conditions in '### Initialize Application Parameters' are met.

            // <CREATE A CHAT CLIENT>

            // <CREATE A CHAT THREAD>

            // <CREATE A CHAT THREAD CLIENT>

            // <SEND A MESSAGE>
            
            // <RECEIVE CHAT MESSAGES>

            // <ADD A USER>

            // <LIST USERS>

            // <REMOVE A USER>
            
            // <<SEND A TYPING NOTIFICATION>>
            
            // <<SEND A READ RECEIPT>>
               
            // <<LIST READ RECEIPTS>>
        } catch (Exception e){
            System.out.println("Quickstart failed: " + e.getMessage());
        }
    }

Alkalmazásparaméterek inicializálása

Megjegyzés:

Az inicializálást ApplicationConstantsMainActivity.java hozzá kell adni, ha az alábbi feltételek valamelyike teljesül: 1. A leküldéses értesítési funkció NINCS engedélyezve. 2. Az Androidhoz készült Azure Communication Chat-kódtár verziója a < "2.0.0". Ellenkező esetben tekintse meg a 11. lépést az Android leküldéses értesítéseiben. Tekintse meg a referenciaként használt SDK-verzió mintaALKALMAZÁSát.

ACS_ENDPOINT, FIRST_USER_ID és FIRST_USER_ACCESS_TOKEN a rendszer az Azure-függvény meghívásából adja vissza. A részletekért tekintse meg az Azure-függvények integrációját . A paraméterek listájának inicializálásához az Azure-függvény meghívásának válaszát használjuk:

ACS_ENDPOINT: a Communication Services-erőforrás végpontja.
FIRST_USER_ID és SECOND_USER_ID: a Communication Services-erőforrás által létrehozott érvényes Communication Services-felhasználói azonosítók.
FIRST_USER_ACCESS_TOKEN: a communication Services hozzáférési jogkivonata a következőhöz <FIRST_USER_ID>: .

Kódblokk az alkalmazásparaméterek inicialításához az Azure-függvény meghívásával:

try {
        UserTokenClient userTokenClient = new UserTokenClient(AZURE_FUNCTION_URL);
        //First user context
        userTokenClient.getNewUserContext();
        ACS_ENDPOINT = userTokenClient.getACSEndpoint();
        FIRST_USER_ID = userTokenClient.getUserId();
        FIRST_USER_ACCESS_TOKEN = userTokenClient.getUserToken();
        COMMUNICATION_TOKEN_CREDENTIAL = new CommunicationTokenCredential(FIRST_USER_ACCESS_TOKEN);
        //Second user context
        userTokenClient.getNewUserContext();
        SECOND_USER_ID = userTokenClient.getUserId();
    } catch (Throwable throwable) {
        //Your handling code
        logger.logThrowableAsError(throwable);
    }

Csevegőügyfél létrehozása

Cserélje le a megjegyzést <CREATE A CHAT CLIENT> a következő kódra (helyezze az importálási utasításokat a fájl tetejére):

import com.azure.android.core.http.policy.UserAgentPolicy;

chatAsyncClient = new ChatClientBuilder()
    .endpoint(endpoint)
    .credential(new CommunicationTokenCredential(firstUserAccessToken))
    .addPolicy(new UserAgentPolicy(APPLICATION_ID, SDK_NAME, sdkVersion))
    .buildAsyncClient();

Objektummodell

Az alábbi osztályok és felületek a JavaScripthez készült Azure Communication Services Chat SDK néhány fő funkcióját kezelik.

Name	Leírás
ChatClient/ChatAsyncClient	Ez az osztály a Csevegés funkcióhoz szükséges. Példányosíthatja az előfizetés adataival, és használatával létrehozhat, lekérhet, törölhet szálakat, és feliratkozhat csevegési eseményekre.
ChatThreadClient/ChatThreadAsyncClient	Ez az osztály szükséges a Csevegési szál funkcióhoz. Egy példányt a ChatClienten keresztül szerezhet be, és használatával üzeneteket küldhet,fogadhat/frissíthet/törölhet, felhasználókat vehet fel/távolíthat el/kérhet le, gépelési értesítéseket és olvasási visszaigazolásokat küldhet.

Csevegési szál indítása

A mi használatával létrehozunk ChatAsyncClient egy új szálat egy kezdeti felhasználóval.

Az <CREATE A CHAT THREAD> megjegyzés helyére írja be az alábbi kódot:

// A list of ChatParticipant to start the thread with.
List<ChatParticipant> participants = new ArrayList<>();
// The display name for the thread participant.
String displayName = "initial participant";
participants.add(new ChatParticipant()
    .setCommunicationIdentifier(new CommunicationUserIdentifier(firstUserId))
    .setDisplayName(displayName));

// The topic for the thread.
final String topic = "General";
// Optional, set a repeat request ID.
final String repeatabilityRequestID = "";
// Options to pass to the create method.
CreateChatThreadOptions createChatThreadOptions = new CreateChatThreadOptions()
    .setTopic(topic)
    .setParticipants(participants)
    .setIdempotencyToken(repeatabilityRequestID);

CreateChatThreadResult createChatThreadResult =
    chatAsyncClient.createChatThread(createChatThreadOptions).get();
ChatThreadProperties chatThreadProperties = createChatThreadResult.getChatThreadProperties();
threadId = chatThreadProperties.getId();

Csevegőszál-ügyfél lekérése

Most, hogy létrehoztunk egy csevegési szálat, beszerezünk egy ChatThreadAsyncClient műveletet a szálon belül. Az <CREATE A CHAT THREAD CLIENT> megjegyzés helyére írja be az alábbi kódot:

ChatThreadAsyncClient chatThreadAsyncClient = new ChatThreadClientBuilder()
    .endpoint(endpoint)
    .credential(new CommunicationTokenCredential(firstUserAccessToken))
    .addPolicy(new UserAgentPolicy(APPLICATION_ID, SDK_NAME, sdkVersion))
    .chatThreadId(threadId)
    .buildAsyncClient();

Üzenet küldése csevegési szálra

Most küldünk üzenetet erre a szálra.

Az <SEND A MESSAGE> megjegyzés helyére írja be az alábbi kódot:

// The chat message content, required.
final String content = "Please take a look at the attachment";

// The display name of the sender, if null (i.e. not specified), an empty name will be set.
final String senderDisplayName = "An important person";

// Use metadata optionally to include any additional data you want to send along with the message.
// This field provides a mechanism for developers to extend chat message functionality and add
// custom information for your use case. For example, when sharing a file link in the message, you
// might want to add 'hasAttachment:true' in metadata so that recipient's application can parse
// that and display accordingly.
final Map<String, String> metadata = new HashMap<String, String>();
metadata.put("hasAttachment", "true");
metadata.put("attachmentUrl", "https://contoso.com/files/attachment.docx");

SendChatMessageOptions chatMessageOptions = new SendChatMessageOptions()
    .setType(ChatMessageType.TEXT)
    .setContent(content)
    .setSenderDisplayName(senderDisplayName)
    .setMetadata(metadata);

// A string is the response returned from sending a message, it is an id, which is the unique ID
// of the message.
chatMessageId = chatThreadAsyncClient.sendMessage(chatMessageOptions).get().getId();

Csevegőüzenetek fogadása csevegőszálból

Valós idejű értesítések

Valós idejű jelzéssel előfizethet az új bejövő üzenetekre, és ennek megfelelően frissítheti az aktuális üzeneteket a memóriában. Az Azure Communication Services támogatja azoknak az eseményeknek a listáját, amelyekre előfizethet.

Cserélje le a megjegyzést <RECEIVE CHAT MESSAGES> a következő kódra (helyezze az importálási utasításokat a fájl tetejére):


// Start real time notification
chatAsyncClient.startRealtimeNotifications(firstUserAccessToken, getApplicationContext());

// Register a listener for chatMessageReceived event
chatAsyncClient.addEventHandler(ChatEventType.CHAT_MESSAGE_RECEIVED, (ChatEvent payload) -> {
    ChatMessageReceivedEvent chatMessageReceivedEvent = (ChatMessageReceivedEvent) payload;
    // You code to handle chatMessageReceived event
    
});

Fontos

Ismert probléma: Ha az Android Chat és a Calling SDK együttes használata ugyanabban az alkalmazásban történik, a Csevegő SDK valós idejű értesítési funkciója nem működik. Előfordulhat, hogy függőségi problémát old meg. Miközben dolgozunk egy megoldáson, kikapcsolhatja a valós idejű értesítések funkciót úgy, hogy hozzáadja a következő függőségi információkat az alkalmazás build.gradle fájljához, és ehelyett lekérdezi a GetMessages API-t a bejövő üzenetek felhasználók számára való megjelenítéséhez.

implementation ("com.azure.android:azure-communication-chat:1.0.0") {
    exclude group: 'com.microsoft', module: 'trouter-client-android'
}
implementation 'com.azure.android:azure-communication-calling:1.0.0'

Vegye figyelembe a fenti frissítéssel, hogy ha az alkalmazás megpróbál megérinteni egy értesítési API-t chatAsyncClient.startRealtimeNotifications() , vagy chatAsyncClient.addEventHandler()futásidejű hiba lép fel.

Leküldéses értesítések

A részletekért tekintse meg az Android leküldéses értesítéseit .

Felhasználó hozzáadása résztvevőként a csevegési szálhoz

Az <ADD A USER> megjegyzés helyére írja be az alábbi kódot:

// The display name for the thread participant.
String secondUserDisplayName = "a new participant";
ChatParticipant participant = new ChatParticipant()
    .setCommunicationIdentifier(new CommunicationUserIdentifier(secondUserId))
    .setDisplayName(secondUserDisplayName);
        
chatThreadAsyncClient.addParticipant(participant);

Felhasználók listázása egy szálban

Cserélje le a megjegyzést <LIST USERS> a következő kódra (helyezze az importálási utasításokat a fájl tetejére):

import com.azure.android.core.rest.util.paging.PagedAsyncStream;
import com.azure.android.core.util.RequestContext;

// The maximum number of participants to be returned per page, optional.
int maxPageSize = 10;

// Skips participants up to a specified position in response.
int skip = 0;

// Options to pass to the list method.
ListParticipantsOptions listParticipantsOptions = new ListParticipantsOptions()
    .setMaxPageSize(maxPageSize)
    .setSkip(skip);

PagedAsyncStream<ChatParticipant> participantsPagedAsyncStream =
      chatThreadAsyncClient.listParticipants(listParticipantsOptions, RequestContext.NONE);

participantsPagedAsyncStream.forEach(chatParticipant -> {
    // You code to handle participant
});

Felhasználó eltávolítása csevegőszálból

Most eltávolítjuk a második felhasználót a szálból.

Az <REMOVE A USER> megjegyzést írja felül az alábbi kóddal:

// Using the unique ID of the participant.
chatThreadAsyncClient.removeParticipant(new CommunicationUserIdentifier(secondUserId)).get();

Gépelési értesítés küldése

Az <SEND A TYPING NOTIFICATION> megjegyzést írja felül az alábbi kóddal:

chatThreadAsyncClient.sendTypingNotification().get();

Olvasási visszaigazolás küldése

A fent küldött üzenetről olvasási visszaigazolást küldünk.

Az <SEND A READ RECEIPT> megjegyzést írja felül az alábbi kóddal:

chatThreadAsyncClient.sendReadReceipt(chatMessageId).get();

Olvasási visszaigazolások listázása

Az <READ RECEIPTS> megjegyzést írja felül az alábbi kóddal:

// The maximum number of participants to be returned per page, optional.
maxPageSize = 10;
// Skips participants up to a specified position in response.
skip = 0;
// Options to pass to the list method.
ListReadReceiptOptions listReadReceiptOptions = new ListReadReceiptOptions()
    .setMaxPageSize(maxPageSize)
    .setSkip(skip);

PagedAsyncStream<ChatMessageReadReceipt> readReceiptsPagedAsyncStream =
      chatThreadAsyncClient.listReadReceipts(listReadReceiptOptions, RequestContext.NONE);

readReceiptsPagedAsyncStream.forEach(readReceipt -> {
    // You code to handle readReceipt
});

A kód futtatása

Az Android Studióban nyomja le a Futtatás gombot a projekt létrehozásához és futtatásához. A konzolon megtekintheti a kód kimenetét és a naplózó kimenetét a ChatClientből.

Mintakód

Keresse meg a gitHubon a rövid útmutató véglegesített kódját.

Előfeltételek

Az első lépések előtt győződjön meg arról, hogy:

Azure-fiók létrehozása aktív előfizetéssel. További részletekért lásd : Fiók létrehozása ingyenesen.
A Visual Studio telepítése
Hozzon létre egy Azure Communication Services-erőforrást. További részletekért lásd : Azure Communication Services-erőforrás létrehozása. Ehhez a rövid útmutatóhoz rögzítenie kell az erőforrásvégpontot és a kapcsolati sztring.
Felhasználói hozzáférési jogkivonat. Ügyeljen arra, hogy a hatókört csevegésre állítsa, és jegyezze fel a jogkivonat sztringet, valamint a user_id sztringet. Az Azure CLI használatával az alábbi parancsot is futtathatja a kapcsolati sztring egy felhasználó és egy hozzáférési jogkivonat létrehozásához.
```
az communication identity token issue --scope chat --connection-string "yourConnectionString"
```
További részletekért lásd: Hozzáférési jogkivonatok létrehozása és kezelése az Azure CLI használatával.

Beállítás

Új C#-alkalmazás létrehozása

Egy konzolablakban (például parancsmag, PowerShell vagy Bash) a dotnet new paranccsal hozzon létre egy új konzolalkalmazást a névvel ChatQuickstart. Ez a parancs létrehoz egy egyszerű ""Helló világ!" alkalmazás" C#-projektet egyetlen forrásfájllal: Program.cs.

dotnet new console -o ChatQuickstart

Módosítsa a könyvtárat az újonnan létrehozott alkalmazásmappára, és használja a dotnet build parancsot az alkalmazás fordításához.

cd ChatQuickstart
dotnet build

Telepítse a(z) csomagot

Az Azure Communication Chat SDK telepítése .NET-hez

dotnet add package Azure.Communication.Chat

Objektummodell

Az alábbi osztályok az Azure Communication Services Chat SDK for C# néhány fő funkcióját kezelik.

Name	Leírás
ChatClient	Ez az osztály a Csevegés funkcióhoz szükséges. Példányosíthatja az előfizetés adataival, és szálak létrehozására, lekérésére és törlésére használhatja őket.
ChatThreadClient	Ez az osztály szükséges a Csevegési szál funkcióhoz. Egy példányt a ChatClienten keresztül szerezhet be, és használatával üzeneteket küldhet,fogadhat/frissíthet/törölhet, résztvevőket vehet fel/távolíthat el/kérhet le, gépelési értesítéseket és olvasási visszaigazolásokat küldhet.

Csevegőügyfél létrehozása

Csevegőügyfél létrehozásához használja a Communication Services-végpontot és az előfeltétel-lépések részeként létrehozott hozzáférési jogkivonatot. Az Identity SDK osztályával létre kell hoznia egy felhasználót, és ki kell CommunicationIdentityClient adnia egy jogkivonatot a csevegőügyfélnek való továbbításhoz.

További információ a felhasználói hozzáférési jogkivonatokról.

Ez a rövid útmutató nem foglalja magában a szolgáltatásszint létrehozását a csevegőalkalmazás jogkivonatainak kezeléséhez, bár ajánlott. További információ a csevegési architektúráról

Másolja ki a következő kódrészleteket, és illessze be a forrásfájlba: Program.cs

using Azure;
using Azure.Communication;
using Azure.Communication.Chat;
using System;

namespace ChatQuickstart
{
    class Program
    {
        static async System.Threading.Tasks.Task Main(string[] args)
        {
            // Your unique Azure Communication service endpoint
            Uri endpoint = new Uri("<replace with your resource endpoint>");

            CommunicationTokenCredential communicationTokenCredential = new CommunicationTokenCredential(<Access_Token>);
            ChatClient chatClient = new ChatClient(endpoint, communicationTokenCredential);
        }
    }
}

Csevegési szál indítása

Csevegési szál létrehozása a createChatThread chatClient metódusával

Ezzel topic a csevegéssel témakört adhat hozzá; A témakör akkor frissíthető, ha a csevegőszál a UpdateTopic függvény használatával jött létre.
Tulajdonság használatával participants adja át a ChatParticipant csevegési szálhoz hozzáadni kívánt objektumok listáját. Az ChatParticipant objektum inicializálva van egy CommunicationIdentifier objektummal. CommunicationIdentifier típusú lehet CommunicationUserIdentifier, MicrosoftTeamsUserIdentifier vagy PhoneNumberIdentifier. Például egy CommunicationIdentifier objektum lekéréséhez meg kell adnia egy hozzáférési azonosítót, amelyet a következő utasítással hozott létre a felhasználó létrehozásához

A metódus válaszobjektuma createChatThread tartalmazza a chatThread részleteket. A csevegési szál műveleteinek (például résztvevők hozzáadása, üzenet küldése, üzenet törlése stb.) használatához az chatThreadClient ügyfélpéldánynak példányt kell létrehoznia az GetChatThreadClientChatClient ügyfél metódusával.

var chatParticipant = new ChatParticipant(identifier: new CommunicationUserIdentifier(id: "<Access_ID>"))
{
    DisplayName = "UserDisplayName"
};
CreateChatThreadResult createChatThreadResult = await chatClient.CreateChatThreadAsync(topic: "Hello world!", participants: new[] { chatParticipant });
ChatThreadClient chatThreadClient = chatClient.GetChatThreadClient(threadId: createChatThreadResult.ChatThread.Id);
string threadId = chatThreadClient.Id;

Csevegőszál-ügyfél lekérése

A GetChatThreadClient metódus egy már létező szálügyfélt ad vissza. A létrehozott szálon végzett műveletek végrehajtására használható: tagok hozzáadása, üzenet küldése stb. A threadId a meglévő csevegési szál egyedi azonosítója.

string threadId = "<THREAD_ID>";
ChatThreadClient chatThreadClient = chatClient.GetChatThreadClient(threadId: threadId);

Az összes csevegési szál listázása

A felhasználó által használt összes csevegési szál lekérésére használható GetChatThreads .

AsyncPageable<ChatThreadItem> chatThreadItems = chatClient.GetChatThreadsAsync();
await foreach (ChatThreadItem chatThreadItem in chatThreadItems)
{
    Console.WriteLine($"{ chatThreadItem.Id}");
}

Üzenet küldése csevegési szálra

Üzenet SendMessage küldése egy szálnak.

Az content üzenet tartalmának megadásához szükség van rá.
Az üzenet tartalomtípusához használható type , például "Szöveg" vagy "Html". Ha nincs megadva, a "Szöveg" beállítás be lesz állítva.
A feladó megjelenítendő nevének megadására használható senderDisplayName . Ha nincs megadva, üres sztring lesz beállítva.
Ha metadata szeretné, az üzenettel együtt további adatokat is megadhat. Ez a mező egy mechanizmust biztosít a fejlesztőknek a csevegőüzenetek funkcióinak kibővítésére és a használati esethez tartozó egyéni információk hozzáadására. Ha például megoszt egy fájlhivatkozást az üzenetben, érdemes lehet "hasAttachment:true" értéket hozzáadni a metaadatokhoz, hogy a címzett alkalmazása elemezhesse és ennek megfelelően jelenjen meg.

SendChatMessageOptions sendChatMessageOptions = new SendChatMessageOptions()
{
    Content = "Please take a look at the attachment",
    MessageType = ChatMessageType.Text
};
sendChatMessageOptions.Metadata["hasAttachment"] = "true";
sendChatMessageOptions.Metadata["attachmentUrl"] = "https://contoso.com/files/attachment.docx";

SendChatMessageResult sendChatMessageResult = await chatThreadClient.SendMessageAsync(sendChatMessageOptions);

string messageId = sendChatMessageResult.Id;

Csevegőüzenetek fogadása csevegőszálból

A csevegőüzenetek lekéréséhez lekérdezheti a GetMessages metódust a csevegőszál-ügyfélen megadott időközönként.

AsyncPageable<ChatMessage> allMessages = chatThreadClient.GetMessagesAsync();
await foreach (ChatMessage message in allMessages)
{
    Console.WriteLine($"{message.Id}:{message.Content.Message}");
}

GetMessages nem kötelező DateTimeOffset paramétert vesz fel. Ha ez az eltolás meg van adva, az azt követően kapott, frissített vagy törölt üzeneteket fog kapni. Vegye figyelembe, hogy az eltolási idő előtt fogadott, de a visszaküldött üzeneteket is később szerkesztik vagy távolítják el.

GetMessages Az üzenet legújabb verzióját adja vissza, beleértve az üzenet UpdateMessage használatával és használatával történt módosításokat és DeleteMessagetörléseket is. Törölt üzenetek esetén egy dátum/idő értéket ad vissza, chatMessage.DeletedOn amely jelzi az üzenet törlésének időpontját. Szerkesztett üzenetek esetén egy dátumidőt ad vissza, chatMessage.EditedOn amely jelzi, hogy mikor lett szerkesztve az üzenet. Az üzenetlétrehozás eredeti időpontja a következővel chatMessage.CreatedOnérhető el, és az üzenetek megrendeléséhez használható.

GetMessages A különböző típusú üzeneteket ad vissza, amelyek azonosíthatók a következővel chatMessage.Type: . Ezek a típusok a következők:

Text: Egy száltag által küldött szokásos csevegőüzenet.
Html: Formázott szöveges üzenet. Vegye figyelembe, hogy a Communication Services felhasználói jelenleg nem tudnak RichText-üzeneteket küldeni. Ezt az üzenettípust a Teams-felhasználóktól a Kommunikációs szolgáltatások felhasználóinak a Teams Interop-forgatókönyvekben küldött üzenetek támogatják.
TopicUpdated: A témakör frissítését jelző rendszerüzenet. (olvasható)
ParticipantAdded: Rendszerüzenet, amely azt jelzi, hogy egy vagy több résztvevő lett hozzáadva a csevegési szálhoz. (olvasható)
ParticipantRemoved: Rendszerüzenet, amely azt jelzi, hogy egy résztvevő el lett távolítva a csevegési szálból.

További részletekért lásd : Üzenettípusok.

Felhasználó hozzáadása résztvevőként a csevegési szálhoz

Miután létrehozott egy szálat, hozzáadhat és eltávolíthat belőle felhasználókat. A felhasználók hozzáadásával hozzáférést adhat nekik ahhoz, hogy üzeneteket tudjanak küldeni a szálra, és más résztvevőket is hozzáadhatnak vagy eltávolíthatnak. Hívás AddParticipantselőtt győződjön meg arról, hogy új hozzáférési jogkivonatot és identitást szerzett be az adott felhasználóhoz. A felhasználónak szüksége lesz erre a hozzáférési jogkivonatra a csevegőügyfél inicializálásához.

Egy AddParticipants vagy több résztvevőt adhat hozzá a csevegési szálhoz. Az egyes szál-résztvevők támogatott attribútumai a következők:

communicationUser, kötelező, a szál résztvevőjének identitása.
displayName, nem kötelező, a szál résztvevőjének megjelenítendő neve.
shareHistoryTime, nem kötelező, attól az időponttól kezdve, amikor a csevegési előzmények meg lesznek osztva a résztvevővel.

var josh = new CommunicationUserIdentifier(id: "<Access_ID_For_Josh>");
var gloria = new CommunicationUserIdentifier(id: "<Access_ID_For_Gloria>");
var amy = new CommunicationUserIdentifier(id: "<Access_ID_For_Amy>");

var participants = new[]
{
    new ChatParticipant(josh) { DisplayName = "Josh" },
    new ChatParticipant(gloria) { DisplayName = "Gloria" },
    new ChatParticipant(amy) { DisplayName = "Amy" }
};

await chatThreadClient.AddParticipantsAsync(participants: participants);

Szál résztvevőinek lekérése

A csevegési szál résztvevőinek lekérésére használható GetParticipants .

AsyncPageable<ChatParticipant> allParticipants = chatThreadClient.GetParticipantsAsync();
await foreach (ChatParticipant participant in allParticipants)
{
    Console.WriteLine($"{((CommunicationUserIdentifier)participant.User).Id}:{participant.DisplayName}:{participant.ShareHistoryTime}");
}

Olvasási visszaigazolás küldése

Ezzel SendReadReceipt értesítheti a többi résztvevőt arról, hogy a felhasználó felolvassa az üzenetet.

await chatThreadClient.SendReadReceiptAsync(messageId: messageId);

A kód futtatása

Futtassa az alkalmazást az alkalmazáskönyvtárból a dotnet run paranccsal.

dotnet run

Mintakód

Keresse meg a gitHubon a rövid útmutató véglegesített kódját.

Előfeltételek

Az első lépések előtt győződjön meg arról, hogy:

Azure-fiók létrehozása aktív előfizetéssel. További részletekért lásd : Fiók létrehozása ingyenesen.
Telepítse az Xcode-ot és a CocoaPodsot. Az Xcode használatával létrehozhat egy iOS-alkalmazást a rövid útmutatóhoz, a CocoaPods pedig függőségeket telepíthet.
Hozzon létre egy Azure Communication Services-erőforrást. További részletekért tekintse meg a Communication Services-erőforrások létrehozását és kezelését ismertető rövid útmutatót. Ehhez a rövid útmutatóhoz rögzítenie kell az erőforrásvégpontot és a kapcsolati sztring.
Hozzon létre két felhasználót az Azure Communication Servicesben, és adjon ki nekik egy felhasználói hozzáférési jogkivonatot. Ügyeljen arra, hogy a hatókört csevegésre állítsa, és jegyezze fel a jogkivonat sztringet, valamint a user_id sztringet. Ebben a rövid útmutatóban létrehoz egy szálat egy kezdeti résztvevővel, majd hozzáad egy második résztvevőt a szálhoz. Az Azure CLI használatával az alábbi parancsot is futtathatja a kapcsolati sztring egy felhasználó és egy hozzáférési jogkivonat létrehozásához.
```
az communication identity token issue --scope chat --connection-string "yourConnectionString"
```
További részletekért lásd: Hozzáférési jogkivonatok létrehozása és kezelése az Azure CLI használatával.

Beállítás

Új iOS-alkalmazás létrehozása

Nyissa meg az Xcode-ot, és válassza az Új Xcode-projekt létrehozása lehetőséget. Ezután válassza ki az iOS-t platformként és alkalmazásként a sablonhoz.

A projektnévhez írja be a ChatQuickstart nevet. Ezután válassza a Storyboardot felületként, az UIKit alkalmazás delegáltját életciklusként, a Swiftet pedig nyelvként.

Válassza a Tovább lehetőséget, és válassza ki azt a könyvtárat, amelyben létre szeretné hozni a projektet.

A kódtárak telepítése

A CocoaPods használatával telepítse a szükséges Communication Services-függőségeket.

A parancssorból lépjen az iOS-projekt gyökérkönyvtárába ChatQuickstart . Hozzon létre egy Podfile-t a következő paranccsal: pod init.

Nyissa meg a Podfile-t, és adja hozzá a következő függőségeket a ChatQuickstart célhoz:

pod 'AzureCommunicationChat', '~> 1.3.4'

Telepítse a függőségeket a következő paranccsal: pod install. Vegye figyelembe, hogy ez egy Xcode-munkaterületet is létrehoz.

A futtatás pod installután nyissa meg újra a projektet az Xcode-ban az újonnan létrehozott .xcworkspaceelem kiválasztásával.

A helyőrzők beállítása

Nyissa meg a munkaterületet ChatQuickstart.xcworkspace az Xcode-ban, majd nyissa meg ViewController.swift.

Ebben a rövid útmutatóban hozzáadja a kódot az Xcode-konzolhoz viewController, és megtekintheti a kimenetet. Ez a rövid útmutató nem foglalkozik a felhasználói felület iOS-ben való létrehozásával.

A lap tetején importálja viewController.swifta AzureCommunication kódtárakat:AzureCommunicatonChat

import AzureCommunicationCommon
import AzureCommunicationChat

Másolja a következő kódot a viewDidLoad() következő metódusba ViewController:

override func viewDidLoad() {
        super.viewDidLoad()
        // Do any additional setup after loading the view.

        let semaphore = DispatchSemaphore(value: 0)
        DispatchQueue.global(qos: .background).async {
            do {
                // <CREATE A CHAT CLIENT>
                
                // <CREATE A CHAT THREAD>

                // <LIST ALL CHAT THREADS>

                // <GET A CHAT THREAD CLIENT>

                // <SEND A MESSAGE>

                // <SEND A READ RECEIPT >

                // <RECEIVE MESSAGES>

                // <ADD A USER>
                
                // <LIST USERS>
            } catch {
                print("Quickstart failed: \(error.localizedDescription)")
            }
        }
    }

Bemutató célokra egy szemafor használatával szinkronizáljuk a kódot. A következő lépésekben a helyőrzőket mintakódra cseréli az Azure Communication Services csevegési kódtárával.

Csevegőügyfél létrehozása

Csevegőügyfél létrehozásához használja a Communication Services-végpontot és az előfeltétel-lépések részeként létrehozott hozzáférési jogkivonatot.

További információ a felhasználói hozzáférési jogkivonatokról.

Cserélje le a megjegyzést <CREATE A CHAT CLIENT> az alábbi kódrészletre:

let endpoint = "<ACS_RESOURCE_ENDPOINT>"
let credential =
try CommunicationTokenCredential(
    token: "<ACCESS_TOKEN>"
)
let options = AzureCommunicationChatClientOptions()

let chatClient = try ChatClient(
    endpoint: endpoint,
    credential: credential,
    withOptions: options
)

Cserélje le <ACS_RESOURCE_ENDPOINT> az Azure Communication Services-erőforrás végpontjára. Cserélje le <ACCESS_TOKEN> érvényes Communication Services-hozzáférési jogkivonatra.

Objektummodell

Az alábbi osztályok és felületek az iOS-hez készült Azure Communication Services Chat SDK néhány fő funkcióját kezelik.

Name	Leírás
`ChatClient`	Ez az osztály szükséges a csevegési funkcióhoz. Példányosíthatja az előfizetés adataival, és használatával létrehozhat, lekérhet, törölhet szálakat, és feliratkozhat csevegési eseményekre.
`ChatThreadClient`	Ez az osztály szükséges a csevegési szál működéséhez. A példányt az üzenetküldés, fogadás, frissítés és törlés útján `ChatClient`szerezheti be, és használhatja azt. Emellett felhasználók hozzáadására, eltávolítására és lekérésére, gépelési értesítések küldésére és visszaigazolások olvasására is használható.

Csevegési szál indítása

CreateChatThreadResult a csevegési szál létrehozásakor visszaadott válasz. Olyan tulajdonságot chatThread tartalmaz, amely az ChatThreadProperties objektum. Ez az objektum tartalmazza a threadId azonosítót, amely a létrehozott szálon végzett műveletek végrehajtásához használható ChatThreadClient : résztvevők hozzáadása, üzenet küldése stb.

Cserélje le a megjegyzést <CREATE A CHAT THREAD> az alábbi kódrészletre:

let request = CreateChatThreadRequest(
    topic: "Quickstart",
    participants: [
        ChatParticipant(
            id: CommunicationUserIdentifier("<USER_ID>"),
            displayName: "Jack"
        )
    ]
)

var threadId: String?
chatClient.create(thread: request) { result, _ in
    switch result {
    case let .success(result):
        threadId = result.chatThread?.id

    case .failure:
        fatalError("Failed to create thread.")
    }
    semaphore.signal()
}
semaphore.wait()

Cserélje le <USER_ID> érvényes Communication Services-felhasználói azonosítóra.

Itt egy szemapóra használatával várja meg a befejezéskezelőt a folytatás előtt. A későbbi lépésekben a threadId befejezési kezelőnek visszaadott választ fogja használni.

Az összes csevegési szál listázása

A csevegési szál létrehozása után az összes csevegési szálat listázhatjuk a listChatThreads metódus ChatClientmeghívásával. Az <LIST ALL CHAT THREADS> megjegyzés helyére írja be az alábbi kódot:

chatClient.listThreads { result, _ in
    switch result {
    case let .success(threads):
        guard let chatThreadItems = threads.pageItems else {
            print("No threads returned.")
            return
        }

        for chatThreadItem in chatThreadItems {
            print("Thread id: \(chatThreadItem.id)")
        }
    case .failure:
        print("Failed to list threads")
    }
    semaphore.signal()
}
semaphore.wait()

Csevegőszál-ügyfél lekérése

A createClient metódus egy ChatThreadClient már létező szálat ad vissza. A létrehozott szálon végzett műveletek végrehajtására használható: résztvevők hozzáadása, üzenet küldése stb. A threadId a meglévő csevegési szál egyedi azonosítója.

Az <GET A CHAT THREAD CLIENT> megjegyzés helyére írja be az alábbi kódot:

let chatThreadClient = try chatClient.createClient(forThread: threadId!)

Üzenet küldése csevegési szálra

Ezzel a send módszerrel üzenetet küldhet a threadId által azonosított szálnak.

SendChatMessageRequest az üzenetkérelem leírására szolgál:

A content csevegőüzenet tartalmának megadása
A senderDisplayName feladó megjelenítendő nevének megadása
Az üzenet típusának megadására szolgál type , például "szöveg" vagy "html"
Ha metadata szeretné, az üzenettel együtt további adatokat is megadhat. Ez a mező egy mechanizmust biztosít a fejlesztőknek a csevegőüzenetek funkcióinak kibővítésére és a használati esethez tartozó egyéni információk hozzáadására. Ha például megoszt egy fájlhivatkozást az üzenetben, érdemes lehet "hasAttachment:true" értéket hozzáadni a metaadatokhoz, hogy a címzett alkalmazása elemezhesse és ennek megfelelően jelenjen meg.

SendChatMessageResult az üzenet küldésével visszaadott válasz, amely egy azonosítót tartalmaz, amely az üzenet egyedi azonosítója.

Cserélje le a megjegyzést <SEND A MESSAGE> az alábbi kódrészletre:

let message = SendChatMessageRequest(
                        content: "Hello!",
                        senderDisplayName: "Jack",
                        type: .text,
                        metadata: [
                            "hasAttachment": "true",
                            "attachmentUrl": "https://contoso.com/files/attachment.docx"
                        ]
                    )

var messageId: String?

chatThreadClient.send(message: message) { result, _ in
    switch result {
    case let .success(result):
        print("Message sent, message id: \(result.id)")
        messageId = result.id
    case .failure:
        print("Failed to send message")
    }
    semaphore.signal()
}
semaphore.wait()

Olvasási visszaigazolás küldése

Ezzel a sendReadReceipt módszerrel egy felhasználó nevében közzétehet egy olvasási visszaigazolási eseményt egy csevegési szálon. messageId az olvasott csevegőüzenet egyedi azonosítója.

Cserélje le a megjegyzést <SEND A READ RECEIPT> az alábbi kódra:

if let id = messageId {
    chatThreadClient.sendReadReceipt(forMessage: id) { result, _ in
        switch result {
        case .success:
            print("Read receipt sent")
        case .failure:
            print("Failed to send read receipt")
        }
        semaphore.signal()
    }
    semaphore.wait()
} else {
    print("Cannot send read receipt without a message id")
}

Csevegőüzenetek fogadása csevegőszálból

Cserélje le a megjegyzést <RECEIVE MESSAGES> az alábbi kódra. Az értesítések engedélyezése után próbáljon meg új üzeneteket küldeni a ChatMessageReceivedEvents megtekintéséhez.

chatClient.startRealTimeNotifications { result in
    switch result {
    case .success:
        print("Real-time notifications started.")
    case .failure:
        print("Failed to start real-time notifications.")
    }
    semaphore.signal()
}
semaphore.wait()

chatClient.register(event: .chatMessageReceived, handler: { response in
    switch response {
    case let .chatMessageReceivedEvent(event):
        print("Received a message: \(event.message)")
    default:
        return
    }
})

Másik lehetőségként lekérheti a csevegőüzeneteket a listMessages metódus megadott időközönkénti lekérdezésével. Lásd a következő kódrészletet: listMessages

chatThreadClient.listMessages { result, _ in
    switch result {
    case let .success(messagesResult):
        guard let messages = messagesResult.pageItems else {
            print("No messages returned.")
            return
        }

        for message in messages {
            print("Received message with id: \(message.id)")
        }

    case .failure:
        print("Failed to receive messages")
    }
    semaphore.signal()
}
semaphore.wait()

Felhasználó hozzáadása résztvevőként a csevegési szálhoz

Miután létrehozott egy szálat, hozzáadhat és eltávolíthat belőle felhasználókat. A felhasználók hozzáadásával hozzáférést adhat nekik ahhoz, hogy üzeneteket tudjanak küldeni a szálra, és más résztvevőket is hozzáadhatnak vagy eltávolíthatnak. Hívás addelőtt győződjön meg arról, hogy új hozzáférési jogkivonatot és identitást szerzett be az adott felhasználóhoz. A felhasználónak szüksége lesz erre a hozzáférési jogkivonatra a csevegőügyfél inicializálásához.

Ezzel a add módszerrel ChatThreadClient adhat hozzá egy vagy több résztvevőt a csevegési szálhoz. Az egyes szál-résztvevők támogatott attribútumai a következők:

id, kötelező, a szál résztvevőjének identitása.
displayName, nem kötelező, a szál résztvevőjének megjelenítendő neve.
shareHistoryTime, nem kötelező, attól az időponttól kezdve, amikor a csevegési előzmények meg lesznek osztva a résztvevővel.

Az <ADD A USER> megjegyzés helyére írja be az alábbi kódot:

let user = ChatParticipant(
    id: CommunicationUserIdentifier("<USER_ID>"),
    displayName: "Jane"
)

chatThreadClient.add(participants: [user]) { result, _ in
    switch result {
    case let .success(result):
        if let errors = result.invalidParticipants, !errors.isEmpty {
            print("Error adding participant")
        } else {
            print("Added participant")
        }
    case .failure:
        print("Failed to add the participant")
    }
    semaphore.signal()
}
semaphore.wait()

Cserélje le <USER_ID> a hozzáadni kívánt felhasználó Kommunikációs szolgáltatások felhasználói azonosítójára.

Felhasználók listázása egy szálban

Ezzel a listParticipants módszerrel lekérheti az összes résztvevőt egy adott csevegési szálhoz.

Az <LIST USERS> megjegyzést írja felül az alábbi kóddal:

chatThreadClient.listParticipants { result, _ in
    switch result {
    case let .success(participantsResult):
        guard let participants = participantsResult.pageItems else {
            print("No participants returned.")
            return
        }

        for participant in participants {
            let user = participant.id as! CommunicationUserIdentifier
            print("User with id: \(user.identifier)")
        }
    case .failure:
        print("Failed to list participants")
    }
    semaphore.signal()
}
semaphore.wait()

Leküldéses értesítések

A leküldéses értesítések értesítik az ügyfeleket a csevegési szál bejövő üzeneteiről olyan helyzetekben, amikor a mobilalkalmazás nem fut az előtérben. Az IOS SDK jelenleg az 1.3.0-s verzióban támogatja a csevegőüzenetek értesítési központtal való küldését. A részletekért tekintse meg a leküldéses értesítés engedélyezése a csevegőalkalmazásban című cikket.

A kód futtatása

Az Xcode-ban nyomja le a Futtatás gombot a projekt létrehozásához és futtatásához. A konzolon megtekintheti a kód kimenetét és a naplózó kimenetét a ChatClientből.

Megjegyzés: Beállítás: NoBuild Settings > Build Options > Enable Bitcode . Az iOS-hez készült AzureCommunicationChat SDK jelenleg nem támogatja a bitkód engedélyezését, az alábbi GitHub-probléma ezt követi nyomon.

Mintakód

Keresse meg a gitHubon a rövid útmutató véglegesített kódját.

Előfeltételek

Aktív előfizetéssel rendelkező Azure-fiók, vagy ingyenes Azure-fiók létrehozása.
Egy aktív Azure Communication Services-erőforrás, vagy hozzon létre egy Communication Services-erőforrást.
Aktív Azure Logic Apps-erőforrás, vagy hozzon létre egy üres logikai alkalmazást a használni kívánt eseményindítóval. A Communication Services csevegési összekötője jelenleg csak műveleteket biztosít, ezért a logikai alkalmazásnak legalább eseményindítóra van szüksége.

Felhasználó létrehozása

Hajtsa végre ezeket a lépéseket a Power Automate-ben szerkesztési módban megnyitott Power Automate-folyamattal.

Új lépés hozzáadása a munkafolyamathoz a Communication Services Identity-összekötő használatával:

A tervezőben az új műveletet hozzáadni kívánt lépés alatt válassza az Új lépés lehetőséget. Másik lehetőségként az új művelet lépések közötti hozzáadásához vigye az egérmutatót a lépések közötti nyíl fölé, jelölje ki a pluszjelet (+), majd válassza a Művelet hozzáadása lehetőséget.
A Művelet kiválasztása keresőmezőbe írja be a Communication Services-identitást. A műveletek listájában válassza a Felhasználó létrehozása lehetőséget.
Adja meg a kapcsolati sztring. A kapcsolati sztring URL-cím lekéréséhez nyissa meg az Azure Communication Services-erőforrást. Az erőforrás menüjében válassza a Kulcsok, majd a Csatlakozás ion sztring lehetőséget. Válassza a másolás ikont a kapcsolati sztring másolásához.
Adja meg a kapcsolat nevét.
Válassza a Speciális beállítások megjelenítése lehetőséget, majd válassza ki a jogkivonat hatókörét. A művelet létrehoz egy hozzáférési jogkivonatot és annak lejárati idejét a megadott hatókörrel. Ez a művelet egy Olyan felhasználói azonosítót is létrehoz, amely a Communication Services felhasználói identitása.
A Jogkivonat hatókörei elemben válassza a csevegést.
Válassza a Létrehozás parancsot. Megjelenik a felhasználói azonosító és a hozzáférési jogkivonat.

Csevegési szál létrehozása

Adjon hozzá egy új műveletet.
A Művelet kiválasztása keresőmezőbe írja be a Communication Services Csevegés parancsot. A műveletek listájában válassza a Csevegési szál létrehozása lehetőséget.
Adja meg a Communication Services végpontJÁNAK URL-címét. A végpont URL-címének az Azure Portalon való lekéréséhez nyissa meg az Azure Communication Services-erőforrást. Az erőforrás menüjében válassza a Kulcsok, majd a Végpont lehetőséget.
Adja meg a kapcsolat nevét.
Válassza ki az előző szakaszban létrehozott hozzáférési jogkivonatot, majd adjon hozzá egy csevegőszál-témakör leírását. Adja hozzá a létrehozott felhasználót, és adja meg a résztvevő nevét.

Üzenet küldése

Adjon hozzá egy új műveletet.
A Művelet kiválasztása keresőmezőbe írja be a Communication Services Csevegés parancsot. A műveletek listájában válassza az Üzenet küldése csevegőszálba lehetőséget.
Adja meg a hozzáférési jogkivonatot, a szál azonosítóját, tartalmát és nevét.

Csevegőszál-üzenetek listázása

Annak ellenőrzése, hogy helyesen küldött-e üzenetet:

Adjon hozzá egy új műveletet.
A Művelet kiválasztása keresőmezőbe írja be a Communication Services Csevegés parancsot. A műveletek listájában válassza a Csevegési szál üzeneteinek listázása lehetőséget.
Adja meg a hozzáférési jogkivonatot és a szálazonosítót.

A logikai alkalmazás tesztelése

A munkafolyamat manuális elindításához a tervező eszköztárán válassza a Futtatás lehetőséget. A munkafolyamat létrehoz egy felhasználót, kiad egy hozzáférési jogkivonatot a felhasználónak, majd eltávolítja a jogkivonatot, és törli a felhasználót. További információkért tekintse át a munkafolyamat futtatásának módját.

Most válassza a Csevegőszál-üzenetek listázása lehetőséget. A művelet kimeneteiben ellenőrizze az elküldött üzenetet.

Screenshot that shows the Azure Communication Services Chat connector Send chat message action results.

Munkafolyamat-erőforrások törlése

A logikai alkalmazás munkafolyamatának és a kapcsolódó erőforrások törléséhez tekintse át a Logic Apps-erőforrások törlésének módját.

Clean up resources

Ha törölni és eltávolítani szeretne egy Communication Services-előfizetést, törölheti az erőforrást vagy az erőforráscsoportot. Az erőforráscsoport törlése a hozzá társított egyéb erőforrásokat is törli. További információ az erőforrások tisztításáról.

Következő lépések

Ebben a rövid útmutatóban megtanulta, hogyan:

Csevegőügyfél létrehozása
Szál létrehozása két felhasználóval
Üzenet küldése a szálnak
Üzenetek fogadása egy szálról
Felhasználók eltávolítása egy szálból

A Csevegés főalkalmazás kipróbálása

A következőket is érdemes lehet elvégeznie:

A felhasználói felületi kódtár használatának első lépései
Tudnivalók a csevegési fogalmakról
Ismerkedés a Csevegő SDK-val
Csevegő SDK használata a React natív alkalmazásban.

Megosztás a következőn keresztül:

Rövid útmutató: Csevegés hozzáadása az alkalmazáshoz

Előfeltételek

Beállítás

A bővítmény hozzáadása

Bejelentkezés az Azure CLI-be

(Nem kötelező) Azure CLI-identitásműveletek használata végpont vagy hozzáférési jogkivonat átadása nélkül

A végpont tárolása környezeti változóban

A hozzáférési jogkivonat tárolása környezeti változóban

Operations

Csevegési szál indítása

Csevegőszál témakörének frissítése

Az összes csevegési szál listázása

Üzenet küldése csevegési szálra

Csevegőüzenetek listázása csevegési szálon

Csevegőüzenet fogadása csevegőszálból

Olvasási visszaigazolás küldése

Felhasználó hozzáadása résztvevőként a csevegési szálhoz

Csevegési szál résztvevőinek listázása

Résztvevő eltávolítása csevegési szálból

Előfeltételek

Beállítás

Új webalkalmazás létrehozása

A csomagok telepítése

Az alkalmazás-keretrendszer beállítása

Csevegőügyfél létrehozása

A kód futtatása

Objektummodell

Csevegési szál indítása

Csevegőszál-ügyfél lekérése

Az összes csevegési szál listázása

Üzenet küldése csevegési szálra

Csevegőüzenetek fogadása csevegőszálból

Felhasználó hozzáadása résztvevőként a csevegési szálhoz

Felhasználók listázása csevegési szálon

Felhasználó eltávolítása csevegőszálból

Feliratkozás valós idejű értesítések kapcsolati állapotára

Mintakód

Előfeltételek

Beállítás

Új Python-alkalmazás létrehozása

Az SDK telepítése

Objektummodell

Csevegőügyfél létrehozása

Csevegési szál indítása

Csevegőszál-ügyfél lekérése

Az összes csevegési szál listázása

Üzenet küldése csevegési szálra

Csevegőüzenetek fogadása csevegőszálból

Olvasási visszaigazolás küldése

Felhasználó hozzáadása résztvevőként a csevegési szálhoz

Csevegési szál résztvevőinek listázása

A kód futtatása

Mintakód

Előfeltételek

Beállítás

Új Java-alkalmazás létrehozása

A csevegő SDK csomaghivatkozásainak hozzáadása

Objektummodell

Csevegőügyfél létrehozása

Csevegési szál indítása

Csevegési szálak listázása

Csevegőszál-ügyfél lekérése

Üzenet küldése csevegési szálra

Csevegőüzenetek fogadása csevegőszálból

Olvasási visszaigazolás küldése

Csevegés résztvevőinek listázása

Felhasználó hozzáadása résztvevőként a csevegési szálhoz

A kód futtatása

Mintakód

Előfeltételek

Beállítás

Új androidos alkalmazás létrehozása

A kódtárak telepítése

Metafájlok kizárása a root build.gradle csomagolási beállításaiban

(Alternatív) Kódtárak telepítése a Mavenen keresztül

Azure-függvény beállítása

Alkalmazásállandók beállítása:

A helyőrzők beállítása

Alkalmazásparaméterek inicializálása