Smart Communications
Starts here:
Chat, Video, AI

import SwiftUI
import Quickblox
import QuickBloxUIKit
let APP_ID: UInt = 0 // "your_application_id"
let APP_KEY = "your_auth_key"
let APP_SECRET = "your_auth_secret"
let ACCOUNT_KEY = "your_account_key"
let USER_LOGIN = "your_user_login"
let USER_PASSWORD = "your_user_password"
final class QuickBloxUIKitViewModel: ObservableObject {
 public enum State { case authorized, loading }
 
 @Published var state: State = .loading
 
 init() {
 Quickblox.initWithApplicationId(APP_ID,
 authKey: APP_KEY,
 authSecret: APP_SECRET,
 accountKey: ACCOUNT_KEY)
 Task { try await authorize() }
 }
 
 @MainActor public func authorize() async throws {
 try await QBRequest.login(USER_LOGIN, password: USER_PASSWORD)
 state = .authorized
 }
}
struct QuickBloxUIKitView: View {
 @StateObject var viewModel = QuickBloxUIKitViewModel()
 
 var body: some View {
 switch viewModel.state {
 case .loading: ProgressView()
 case .authorized: QuickBloxUIKit.dialogsView()
 }
 }
}
@main struct Application: App {
 var body: some Scene {
 WindowGroup { QuickBloxUIKitView() }
 }
}
 

//Init SDK
private const val APPLICATION_ID = "your_application_id"
private const val AUTH_KEY = "your_auth_key"
private const val AUTH_SECRET = "your_auth_secret"
private const val ACCOUNT_KEY = "your_account_key"
class App : Application() {
 override fun onCreate() {
 super.onCreate()
 QBSDK.init(applicationContext, APPLICATION_ID, AUTH_KEY, AUTH_SECRET, ACCOUNT_KEY)
 }
}
//Place in your project where you want to integrate the QuickBlox UI Kit
//Authenticate user and init UI Kit
class MainActivity : AppCompatActivity() {
 override fun onCreate(savedInstanceState: Bundle?) {
 super.onCreate(savedInstanceState)
 setContentView(R.layout.activity_main)
 val user = QBUser()
 user.login = "userlogin"
 user.password = "userpassword"
 QBUsers.signIn(user).performAsync(object : QBEntityCallback {
 override fun onSuccess(user: QBUser?, bundle: Bundle?) {
 // init Quickblox UIKit
 QuickBloxUiKit.init(applicationContext)
 // show Dialogs screen
 DialogsActivity.show(this@MainActivity)
 }
 override fun onError(exception: QBResponseException?) {
 // handle exception
 }
 })
 }
}
 

import React, { useEffect } from 'react';
// @ts-ignore
import * as QB from "quickblox/quickblox";
import {
 QuickBloxUIKitProvider,
 qbDataContext,
 QuickBloxUIKitDesktopLayout, LoginData, AuthorizationData, QBDataContextType,
} from 'quickblox-react-ui-kit';
import { QBConfig } from './QBconfig';
import './App.css';
function App() {
 const currentUser: LoginData = {
 login: '',
 password: '',
 };
 const qbUIKitContext: QBDataContextType = React.useContext(qbDataContext);
 const [isUserAuthorized, setUserAuthorized] = React.useState(false);
 const [isSDKInitialized, setSDKInitialized] = React.useState(false);
 const prepareSDK = async (): Promise => {
 // check if we have installed SDK
 if ((window as any).QB === undefined) {
 if (QB !== undefined) {
 (window as any).QB = QB;
 } else {
 let QBLib = require('quickblox/quickblox.min');
 (window as any).QB = QBLib;
 }
 }
 const APPLICATION_ID = QBConfig.credentials.appId;
 const AUTH_KEY = QBConfig.credentials.authKey;
 const AUTH_SECRET = QBConfig.credentials.authSecret;
 const ACCOUNT_KEY = QBConfig.credentials.accountKey;
 const CONFIG = QBConfig.appConfig;
 QB.init(APPLICATION_ID, AUTH_KEY, AUTH_SECRET, ACCOUNT_KEY, CONFIG);
 };
 useEffect(() => {
 if (!isSDKInitialized) {
 prepareSDK().then(result => {
 QB.createSession(currentUser, async function (errorCreateSession: any, session: any) {
 if (errorCreateSession) {
 console.log('Create User Session has error:', JSON.stringify(errorCreateSession));
 } else {
 const userId: number = session.user_id;
 const password: string = session.token;
 const paramsConnect = { userId, password };
 QB.chat.connect(paramsConnect, async function (errorConnect: any, resultConnect: any) {
 if (errorConnect) {
 console.log('Can not connect to chat server: ', errorConnect);
 } else {
 const authData: AuthorizationData = {
 userId: userId,
 password: password,
 userName: currentUser.login,
 sessionToken: session.token
 };
 await qbUIKitContext.authorize(authData);
 setSDKInitialized(true);
 setUserAuthorized(true);
 }
 });
 }
 });
 }).catch(
 e => {
 console.log('init SDK has error: ', e)
 });
 }
 }, []);
 return (
 <div>
 <QuickBloxUIKitProvider
 maxFileSize={100 * 1000000}
 accountData={{ ...QBConfig.credentials }}
 qbConfig={{ ...QBConfig }}
 loginData={{
 login: currentUser.login,
 password: currentUser.password,
 }}
 >
 <div className="App">
 {
 // React states indicating the ability to render UI
 isSDKInitialized && isUserAuthorized
 ?
 <QuickBloxUIKitDesktopLayout />
 :
 <div>wait while SDK is initializing...</div>
 }
 </div>
 </QuickBloxUIKitProvider>
 </div>
 );
export default App;