react-native-altibbi 0.1.3 → 0.1.4

package/lib/example/src/screen/Video.js

@@ -0,0 +1,87 @@
+import React, { useRef, useState } from 'react';
+import { TBIPublisher, TBISession, TBISubscriber, TBISubscriberView, } from 'react-native-altibbi';
+import { Dimensions, View, Text } from 'react-native';
+const Video = (props) => {
+    const data = props.route.params.event;
+    const voip = props.route.params.voip;
+    const [audio, setAudio] = useState(true);
+    const [video, setVideo] = useState(!voip);
+    const [camera, setCamera] = useState('front');
+    const sessionRef = useRef(null);
+    const toggleVideo = () => setVideo((prev) => !prev);
+    const toggleAudio = () => setAudio((prev) => !prev);
+    const switchCamera = () => setCamera((prev) => {
+        if (prev === 'front') {
+            return 'back';
+        }
+        else {
+            return 'front';
+        }
+    });
+    const renderSubscribers = (subscribers) => {
+        if (subscribers && subscribers.length > 0) {
+            const { width: screenWidth, height: screenHeight } = Dimensions.get('window');
+            return subscribers.map((streamId) => (React.createElement(TBISubscriberView, { streamId: streamId, style: { width: screenWidth, height: screenHeight } })));
+        }
+    };
+    return (React.createElement(TBISession, { options: {
+            androidZOrder: 'onTop',
+            androidOnTop: 'publisher',
+        }, ref: (ref) => (sessionRef.current = ref), apiKey: data.api_key, sessionId: data.call_id, token: data.token, eventHandlers: {
+            streamDestroyed: (event) => { },
+            error: (event) => { },
+            otrnError: (event) => { },
+        } },
+        React.createElement(TBISubscriber, { eventHandlers: {
+                error: (event) => { },
+                otrnError: (event) => { },
+            } }, renderSubscribers),
+        React.createElement(TBIPublisher, { style: {
+                position: 'absolute',
+                width: 100,
+                height: 100,
+                top: 0,
+                margin: 5,
+                right: 0,
+            }, properties: {
+                cameraPosition: camera,
+                publishVideo: video,
+                publishAudio: audio,
+                enableDtx: true,
+            }, eventHandlers: {
+                streamDestroyed: (event) => { },
+                error: (event) => { },
+                otrnError: (event) => { },
+            } }),
+        React.createElement(View, { style: {
+                flexDirection: 'row',
+                padding: 8,
+                position: 'absolute',
+                backgroundColor: 'white',
+                bottom: 0,
+                left: 0,
+                right: 0,
+                justifyContent: 'center',
+            } },
+            React.createElement(Text, { style: {
+                    fontSize: 20,
+                    marginRight: 10,
+                    color: video ? 'blue' : 'red',
+                }, onPress: () => toggleVideo() },
+                "video (",
+                video ? 'T' : 'F',
+                ")"),
+            React.createElement(Text, { style: {
+                    fontSize: 20,
+                    marginRight: 10,
+                    color: audio ? 'blue' : 'red',
+                }, onPress: () => toggleAudio() },
+                "audio (",
+                audio ? 'T' : 'F',
+                ")"),
+            React.createElement(Text, { style: { fontSize: 20, marginRight: 10 }, onPress: () => switchCamera() },
+                "camera (",
+                camera,
+                ")"))));
+};
+export default Video;

package/lib/example/src/screen/WaitingRoom.js

@@ -0,0 +1,108 @@
+import React, { useEffect } from 'react';
+import { View, Text, ActivityIndicator } from 'react-native';
+import { TBIConstants, TBISocketEvent, TBISocketMember, } from 'react-native-altibbi';
+import { cancelConsultation } from 'react-native-altibbi';
+import { getLastConsultation } from 'react-native-altibbi';
+import { TBISocket } from 'react-native-altibbi';
+const WaitingRoom = (props) => {
+    const { channel, socketParams, consultationId } = props?.route?.params;
+    const instance = TBISocket.getInstance();
+    const disconnect = () => instance?.disconnect();
+    const log = (line) => {
+        console.log(line);
+    };
+    const onConnectionStateChange = (currentState, previousState) => {
+        log(`onConnectionStateChange. previousState=${previousState} newState=${currentState}`);
+    };
+    const onError = (message, code, error) => {
+        log(`onError: ${message} code: ${code} exception: ${error}`);
+    };
+    const onEvent = (eventData) => {
+        if (eventData && eventData.eventName === 'call-status') {
+            let event = JSON.parse(eventData.data);
+            if (event.status === 'in_progress') {
+                getCurrentConsultationInfo();
+            }
+        }
+    };
+    const getCurrentConsultationInfo = () => {
+        getLastConsultation().then((res) => {
+            console.log(res);
+            redirectToNext(res.data[0]);
+        });
+    };
+    const onSubscriptionSucceeded = (channelName, data) => {
+        log(`onSubscriptionSucceeded: ${channelName} data: ${JSON.stringify(data)}`);
+    };
+    const onSubscriptionCount = (channelName, subscriptionCount) => {
+        log(`onSubscriptionCount: ${subscriptionCount}, channelName: ${channelName}`);
+    };
+    const onSubscriptionError = (channelName, message, e) => {
+        log(`onSubscriptionError: ${message}, channelName: ${channelName} e: ${e}`);
+    };
+    const onDecryptionFailure = (eventName, reason) => {
+        log(`onDecryptionFailure: ${eventName} reason: ${reason}`);
+    };
+    const onMemberAdded = (channelName, member) => {
+        log(`onMemberAdded: ${channelName} user: ${member}`);
+    };
+    const onMemberRemoved = (channelName, member) => {
+        log(`onMemberRemoved: ${channelName} user: ${member}`);
+    };
+    const connect = async () => {
+        try {
+            await instance.init({
+                ...socketParams,
+                ...{
+                    onConnectionStateChange,
+                    onError,
+                    onEvent,
+                    onSubscriptionSucceeded,
+                    onSubscriptionError,
+                    onDecryptionFailure,
+                    onMemberAdded,
+                    onMemberRemoved,
+                    onSubscriptionCount,
+                },
+            });
+            await instance.subscribe({ channelName: channel });
+            await instance.connect();
+        }
+        catch (e) {
+            throw new Error(`${e}`);
+        }
+    };
+    const redirectToNext = (parmas) => {
+        if (parmas.status === 'in_progress') {
+            if (parmas.chatConfig) {
+                props.navigation.navigate('ChatRoom', {
+                    event: parmas.chatConfig,
+                });
+            }
+            else if (parmas.videoConfig) {
+                props.navigation.navigate('Video', {
+                    event: parmas.videoConfig,
+                });
+            }
+            else if (parmas.voipConfig) {
+                props.navigation.navigate('Video', {
+                    event: parmas.voipConfig,
+                    voip: true,
+                });
+            }
+        }
+    };
+    useEffect(() => {
+        redirectToNext(props?.route?.params);
+        connect().then();
+    }, []);
+    return (React.createElement(View, null,
+        React.createElement(Text, { style: { marginVertical: 20, fontSize: 20 } }, "Waiting For Doctor"),
+        React.createElement(ActivityIndicator, { size: 'large' }),
+        React.createElement(Text, { onPress: () => {
+                cancelConsultation(consultationId).then(() => {
+                    props.navigation.goBack();
+                });
+            }, style: { color: 'blue', fontSize: 20 } }, "Cancel current consultation")));
+};
+export default WaitingRoom;

package/lib/src/connection.js

@@ -0,0 +1,247 @@
+import { TBIConstants } from './service';
+export const Methods = {
+    get: 'GET',
+    post: 'POST',
+    delete: 'DELETE',
+    put: 'PUT',
+};
+const fetchData = (url, request, timeout) => Promise.race([
+    fetch(url, request).catch((error) => {
+        throw Error(`Fetch Error  ${error}`);
+    }),
+    new Promise((_, reject) => setTimeout(() => reject(new Error('request timeout')), timeout)),
+]).catch((e) => {
+    throw Error(`Fetch Error : ${e}`);
+});
+export const request = async ({ method, data, endPoint, path, type, fileName, download, }) => {
+    if (!TBIConstants.baseURL) {
+        return {
+            message: 'Add your baseURL to Init',
+        };
+    }
+    const headers = {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${TBIConstants.token}`,
+        'accept-language': TBIConstants.language,
+    };
+    let url = `${TBIConstants.baseURL}/v1/${endPoint}`;
+    let body;
+    if (method === Methods.get) {
+        url = url + '?' + new URLSearchParams(data).toString();
+    }
+    else if (path) {
+        const formData = new FormData();
+        formData.append('file', {
+            uri: path,
+            type: type,
+            name: fileName,
+        });
+        body = formData;
+        headers['Content-Type'] = 'multipart/form-data';
+    }
+    else {
+        if (data && data.expand) {
+            url = url + '?' + new URLSearchParams({ expand: data.expand }).toString();
+        }
+        body = JSON.stringify(data);
+    }
+    const requestConfig = {
+        method,
+        headers,
+        body,
+    };
+    const timeOut = path ? 180000 : 30000;
+    const apiResponse = await fetchData(url, requestConfig, timeOut);
+    if (download) {
+        return apiResponse;
+    }
+    const response = await apiResponse.text();
+    const responseData = response ? JSON.parse(response) : '';
+    return {
+        status: apiResponse.status,
+        data: responseData,
+    };
+};
+export const getUser = async (user_id) => {
+    const response = await request({
+        method: Methods.get,
+        data: {},
+        endPoint: `users/${user_id}`,
+    });
+    if (response.status === 200) {
+        return response;
+    }
+    throw Error(JSON.stringify(response));
+};
+export const getUsers = async (page = 1, perPage = 20) => {
+    const response = await request({
+        method: Methods.get,
+        data: { page, 'per-page': perPage },
+        endPoint: `users`,
+    });
+    if (response.status === 200) {
+        return response;
+    }
+    throw Error(JSON.stringify(response));
+};
+export const createUser = async (user) => {
+    const response = await request({
+        method: Methods.post,
+        data: user,
+        endPoint: `users`,
+    });
+    if (response.status === 201) {
+        return response;
+    }
+    throw Error(JSON.stringify(response));
+};
+export const updateUser = async (user, user_id) => {
+    const response = await request({
+        method: Methods.put,
+        data: user,
+        endPoint: `users/${user_id}`,
+    });
+    if (response.status === 201) {
+        return response;
+    }
+    throw Error(JSON.stringify(response));
+};
+export const deleteUser = async (user_id) => {
+    const response = await request({
+        method: Methods.delete,
+        data: {},
+        endPoint: `users/${user_id}`,
+    });
+    if (response.status === 204) {
+        return response;
+    }
+    throw Error(JSON.stringify(response));
+};
+export const createConsultation = async ({ question, medium, user_id, mediaIds, followUpId, }) => {
+    if (!question || !medium || !user_id) {
+        throw Error('missing field');
+    }
+    const data = {
+        question,
+        medium,
+        user_id,
+        media_ids: mediaIds,
+        expand: 'pusherAppKey,parentConsultation,consultations,user,media,pusherChannel,' +
+            'chatConfig,chatHistory,voipConfig,videoConfig,recommendation',
+        followUpId,
+    };
+    const response = await request({
+        method: Methods.post,
+        data,
+        endPoint: `consultations`,
+    });
+    if (response.status === 201) {
+        return response;
+    }
+    throw Error(JSON.stringify(response));
+};
+export const getConsultationInfo = async (consultation_id) => {
+    const response = await request({
+        method: Methods.get,
+        data: {
+            expand: 'pusherAppKey,parentConsultation,consultations,user,media,pusherChannel,' +
+                'chatConfig,chatHistory,voipConfig,videoConfig,recommendation',
+        },
+        endPoint: `consultations/${consultation_id}`,
+    });
+    if (response.status === 200) {
+        if (response.data && response.data.pusherAppKey) {
+            response.data.socketParams = {
+                apiKey: response.data.pusherAppKey,
+                cluster: 'eu',
+                authEndpoint: `${TBIConstants.baseURL}/v1/auth/pusher?access-token=${TBIConstants.token}`,
+            };
+        }
+        return response;
+    }
+    throw Error(JSON.stringify(response));
+};
+export const getLastConsultation = async () => {
+    const response = await request({
+        method: Methods.get,
+        data: {
+            'per-page': 1,
+            'sort': '-id',
+            'expand': 'pusherAppKey,parentConsultation,consultations,user,media,pusherChannel,' +
+                'chatConfig,chatHistory,voipConfig,videoConfig,recommendation',
+        },
+        endPoint: `consultations`,
+    });
+    if (response.status === 200) {
+        if (response.data && response.data[0] && response.data[0].pusherAppKey) {
+            response.data[0].socketParams = {
+                apiKey: response?.data?.[0]?.pusherAppKey,
+                cluster: 'eu',
+                authEndpoint: `${TBIConstants.baseURL}/v1/auth/pusher?access-token=${TBIConstants.token}`,
+            };
+        }
+        return response;
+    }
+    throw Error(JSON.stringify(response));
+};
+export const getConsultationList = async (user_id, page = 1, perPage = 20) => {
+    if (!user_id) {
+        throw Error('missing user id');
+    }
+    const response = await request({
+        method: Methods.get,
+        data: {
+            page,
+            'per-page': perPage,
+            'filter[user_id]': user_id,
+            'expand': 'pusherAppKey,parentConsultation,consultations,user,media,pusherChannel,' +
+                'chatConfig,chatHistory,voipConfig,videoConfig,recommendation',
+        },
+        endPoint: `consultations`,
+    });
+    if (response.status === 200) {
+        return response;
+    }
+    throw Error(JSON.stringify(response));
+};
+export const deleteConsultation = async (consultation_id) => {
+    const response = await request({
+        method: Methods.delete,
+        data: {},
+        endPoint: `consultations/${consultation_id}`,
+    });
+    if (response.status === 204) {
+        return response;
+    }
+    throw Error(JSON.stringify(response));
+};
+export const cancelConsultation = async (consultation_id) => {
+    const response = await request({
+        method: Methods.post,
+        data: {},
+        endPoint: `consultations/${consultation_id}/cancel`,
+    });
+    if (response.status === 200) {
+        return response;
+    }
+    throw Error(JSON.stringify(response));
+};
+export const uploadMedia = async (path, type, fileName) => {
+    const response = await request({
+        method: Methods.post,
+        endPoint: `media`,
+        data: {},
+        path,
+        type,
+        fileName,
+    });
+    if (response.status === 200) {
+        return response;
+    }
+    throw Error(JSON.stringify(response));
+};
+export const getPrescription = (consultation_id) => request({
+    method: Methods.get,
+    endPoint: `consultations/${consultation_id}/download-prescription`,
+    download: true,
+});

package/lib/src/data.js

@@ -0,0 +1,19 @@
+export const materialStatusArray = [
+    'single',
+    'married',
+    'divorced',
+    'widow',
+];
+export const bloodTypeArray = [
+    'A+',
+    'B+',
+    'AB+',
+    'O+',
+    'A-',
+    'B-',
+    'AB-',
+    'O-',
+];
+export const boolStringArray = ['yes', 'no'];
+export const genderTypeArray = ['male', 'female'];
+export const MediumArray = ['chat', 'gsm', 'voip', 'video'];

package/lib/src/index.js

@@ -0,0 +1,10 @@
+import OT, { OTPublisher, OTSession, OTSubscriber, OTSubscriberView, } from './video';
+export { OTSession as TBISession, OTPublisher as TBIPublisher, OTSubscriber as TBISubscriber, OTSubscriberView as TBISubscriberView, OT as TBIVideo, };
+export { default as AltibbiChat } from '@sendbird/chat';
+export { BaseChannel, ChannelType, PushTriggerOption, RestrictedUser, User, ConnectionHandler, } from '@sendbird/chat';
+export { GroupChannel, GroupChannelHandler, GroupChannelModule, } from '@sendbird/chat/groupChannel';
+export { BaseMessage, ReactionEvent, ThreadInfoUpdateEvent, } from '@sendbird/chat/message';
+export { uploadMedia, getUser, getUsers, createUser, updateUser, deleteUser, getConsultationList, getConsultationInfo, getLastConsultation, createConsultation, deleteConsultation, cancelConsultation, getPrescription, } from './connection';
+export { TBIConstants, init } from './service';
+export { TBISocket, TBISocketChannel, TBISocketMember, TBISocketEvent, } from './scoket';
+export { materialStatusArray, bloodTypeArray, boolStringArray, genderTypeArray, MediumArray, } from './data';