shakebug-react-native 1.0.14

package/src/APIs/EndSession.js

@@ -0,0 +1,32 @@
+const BASE_URL = global.ShakebugSDKEndPointURL;
+const API_KEY = global.ShakebugSDKEndPointURLheaderKey;
+
+async function SessionEndApi(session_id) {
+    try {
+
+        const formData = new FormData();
+        formData.append("method", "endSession")
+        formData.append("sessionid", session_id)
+
+        const response = await fetch(BASE_URL, {
+            method: 'POST',
+            headers: {
+                'API-KEY': API_KEY,
+            },
+            body: formData,
+        });
+
+        const data = await response.json();
+
+        if (data.code === 200 && data.success === true) {
+            return { success: true, message: data.msg };
+        } else {
+            return { success: false, message: data.msg };
+        }
+    } catch (error) {
+        // console.error('Error fetching data:', error);
+        throw error;
+    }
+}
+
+export { SessionEndApi };

package/src/APIs/Event.js

@@ -0,0 +1,39 @@
+import DeviceInfo from "../../DeviceInfo";
+import NetInfo from "../../NetInfo/src";
+
+const BASE_URL = global.ShakebugSDKEndPointURL;
+const API_KEY = global.ShakebugSDKEndPointURLheaderKey;
+
+async function EventApi(application_id, name, value) {
+    try {
+
+        
+        
+        const formData = new FormData();
+        formData.append("method", "event");
+        formData.append("applicationsid", application_id);
+        formData.append("name", name);
+        formData.append("value", value);
+
+        const response = await fetch(BASE_URL, {
+            method: 'POST',
+            headers: {
+                'API-KEY': API_KEY
+            },
+            body: formData,
+        });
+
+        const data = await response.json();
+        
+        if (data.code === 200 && data.success === true) {
+            return { success: true, message: data.msg };
+        } else {
+            return { success: false, message: data.msg };
+        }
+    } catch (error) {
+        // console.error('Error fetching data:', error);
+        throw error;
+    }
+}
+
+export { EventApi };

package/src/APIs/MatchKey.js

@@ -0,0 +1,40 @@
+const BASE_URL = global.ShakebugSDKEndPointURL;
+const API_KEY = global.ShakebugSDKEndPointURLheaderKey;
+
+async function MatchKeyApi(appkey, BundleId) {
+
+    const formData = new FormData();
+    formData.append("method", "matchKeys")
+    formData.append("bundleid", BundleId)
+    formData.append("appkey", appkey)
+
+
+    try {
+        const response = await fetch(BASE_URL, {
+            method: 'POST',
+            headers: {
+                'API-KEY': API_KEY,
+            },
+            body: formData,
+        });
+
+        const data = await response.json();
+ 
+        if (data.code === 200 && data.success === true) {
+            const application_id = data.response_data.application_id;
+            const total_mau = data.response_data.total_mau;
+            const used_mau = data.response_data.used_mau;
+            const total_video = data.response_data.total_video;
+            const used_video = data.response_data.used_video;
+            const video_duration = data.response_data.video_duration; 
+            return { success: true, application_id, total_mau, used_mau, total_video, used_video, video_duration, message: data.msg };
+        } else {
+            return { success: false, message: data.msg };
+        }
+    } catch (error) {
+        // console.error('Error fetching data:', error);
+        throw error;
+    }
+}
+
+export { MatchKeyApi };

package/src/APIs/StartSession.js

@@ -0,0 +1,84 @@
+import DeviceInfo from "../../DeviceInfo";
+import { getLocales } from "../../GetLocals/src";
+
+const BASE_URL = global.ShakebugSDKEndPointURL;
+const API_KEY = global.ShakebugSDKEndPointURLheaderKey;
+
+async function SessionStartApi(latitude, longitude, application_id) {
+
+    let city = "";
+    let state = ""
+
+    if (latitude != "" && latitude != undefined && longitude != "" && longitude != undefined) {
+        try {
+            await fetch(
+                `https://nominatim.openstreetmap.org/reverse?format=json&lat=${latitude}&lon=${longitude}`,
+            )
+                .then(response => response.json())
+                .then(async data => {
+                    state = data.address.state
+                    city = data.address.city
+                })
+        }
+        catch (err) {
+            // console.log("err", err)
+            throw err
+        }
+    }
+
+    let locals = getLocales()
+
+    let uuid = await DeviceInfo.getUniqueId()
+
+    let system_version = await DeviceInfo.getSystemVersion()
+
+    let app_version = await DeviceInfo.getVersion()
+
+    let device_name = await DeviceInfo.getDeviceName()
+
+    let os = await DeviceInfo.getSystemName()
+
+    let phone_carrier = await DeviceInfo.getCarrier()
+
+    let architecture = await DeviceInfo.supportedAbis()
+
+    const formData = new FormData();
+    formData.append("method", "startSession")
+    formData.append("uuid", uuid)
+    formData.append("applicationsid", application_id)
+    formData.append("systemversion", system_version)
+    formData.append("os", os)
+    formData.append("language", locals[0].languageCode)
+    formData.append("country", locals[0].countryCode)
+    formData.append("phonename", device_name)
+    formData.append("devicemodel", architecture[0])
+    formData.append("city", city)
+    formData.append("state", state)
+    formData.append("latitude", latitude)
+    formData.append("longitude", longitude)
+    formData.append("phonecarrier", phone_carrier)
+    formData.append("appversion", app_version)
+
+    try {
+        const response = await fetch(BASE_URL, {
+            method: 'POST',
+            headers: {
+                'API-KEY': API_KEY,
+            },
+            body: formData,
+        });
+
+        const data = await response.json();
+        if (data.code === 200 && data.success === true) {
+            const session_id = data.response_data.session_id;
+            return { success: true, session_id, message: data.msg };
+        } else {
+            return { success: false, message: data.msg };
+        }
+    } catch (error) {
+        // console.error('Error fetching data:', error);
+        // throw error;
+    }
+}
+
+export { SessionStartApi };

package/src/Componanats/CustomAlert.js

@@ -0,0 +1,80 @@
+import React from 'react';
+import { View, Text, Button, StyleSheet, Modal, TouchableOpacity } from 'react-native';
+
+const CustomeAlert = ({color, isVisible, OnPrees, text}) => {
+    
+    return (
+        <Modal
+            transparent={true}
+            visible={isVisible}
+        >
+            <View style={styles.background}>
+                <View style={styles.overlay} />
+
+                <View 
+                    style={[
+                    styles.container, {
+                        height: text.length > 120 ? 300 : text.length < 50 ? 170 : 200
+                    }]}
+                >
+                    <Text style={styles.text}>
+                        {text}
+                    </Text>
+                    
+                    <TouchableOpacity
+                        style={{
+                            width: '100%',
+                            backgroundColor: color,
+                            height: 40,
+                            alignItems: 'center',
+                            justifyContent: 'center',
+                            borderRadius: 8
+                        }}
+                        onPress={OnPrees}
+                    >
+                        <Text
+                            style={{
+                                fontSize: 16,
+                                color: "#fff"
+                            }}
+                        >
+                            Okay
+                        </Text>
+                    </TouchableOpacity>
+                </View>
+            </View>
+        </Modal>
+    );
+};
+
+const styles = StyleSheet.create({
+    background: {
+        flex: 1,
+        justifyContent: 'center',
+        alignItems: 'center',
+    },
+    overlay: {
+        ...StyleSheet.absoluteFillObject,
+        backgroundColor: 'rgba(0, 0, 0, 0.5)', // Slightly transparent overlay
+    },
+    container: {
+        width: '80%',
+        padding: 20,
+        borderRadius: 10,
+        backgroundColor: '#fff', // Solid white background
+        elevation: 5, // Adds shadow for a raised effect on Android
+        shadowColor: '#000', // Adds shadow on iOS
+        shadowOffset: { width: 0, height: 2 },
+        shadowOpacity: 0.25,
+        shadowRadius: 3.84,
+        alignItems: 'center',
+        justifyContent: 'space-around'
+    },
+    text: {
+        fontSize: 16,
+        textAlign: 'center',
+        color: "#000"
+    },
+});
+
+export default CustomeAlert;

package/src/Componanats/ErrorHandler.js

@@ -0,0 +1,80 @@
+import { NativeModules } from 'react-native'
+import DeviceInfo from "../../DeviceInfo";
+import NetInfo from '../../NetInfo/src'
+
+let isErrorHandlerSet = false;
+
+const { ShakebugSDKSharedPreferencesModule } = NativeModules
+
+const AddCrashApi = async (desc) => {
+    let batteryLevel = parseFloat(await DeviceInfo.getBatteryLevel() * 100).toFixed(0);
+    let architecture = await DeviceInfo.supportedAbis();
+    let model = await DeviceInfo.getModel();
+    let created = new Date().toLocaleString();
+    let appversion = DeviceInfo.getVersion();
+    let memory = await DeviceInfo.getTotalMemory() - await DeviceInfo.getUsedMemory()
+    let osversion = await DeviceInfo.getSystemVersion()
+
+    let i = 0;
+    let internetType = "";
+    NetInfo.addEventListener(stat => {
+        if (i == 0) {
+            internetType = stat.type
+        }
+        i++
+    })
+
+    const arr = {
+        session_id: global.session_id,
+        application_id: global.application_id,
+        internetType: internetType,
+        batteryLevel: batteryLevel,
+        architecture: architecture[0],
+        model: model,
+        created: created,
+        appversion: appversion,
+        memory: memory,
+        osversion: osversion,
+        desc: desc.stack
+    }
+
+    ShakebugSDKSharedPreferencesModule.setString("iscrashSaveed", JSON.stringify(arr))
+
+}
+
+// Function to log the error
+const logError = (error, isFatal) => {
+    // Here, you can send the error log to a server or log it to the console
+    let desc = error
+    AddCrashApi(desc)
+    // console.error("Captured Error", error);
+    // Implement sending error to server or other logging mechanism here
+};
+
+// Function to initialize the global error handlers
+const setGlobalErrorHandler = () => {
+    if (isErrorHandlerSet) return;
+
+    // Capture JavaScript errors
+    ErrorUtils.setGlobalHandler((error, isFatal) => {
+        logError(error, isFatal);
+    });
+
+    // TODO: Capture native crashes (Android & iOS)
+    // You might need native modules to capture native crashes.
+
+    // Optionally, capture unhandled promise rejections
+    captureUnhandledRejections();
+
+    isErrorHandlerSet = true;
+};
+
+// Function to handle unhandled promise rejections
+const captureUnhandledRejections = () => {
+    // Listen for unhandled promise rejections
+    window.onunhandledrejection = (reason, promise) => {
+        logError(reason, false);
+    };
+};
+
+export { setGlobalErrorHandler };

package/src/Componanats/GlobalStateContext.js

@@ -0,0 +1,22 @@
+// GlobalStateContext.js
+import React, { createContext, useState, useContext } from 'react';
+
+const GlobalStateContext = createContext();
+
+export const GlobalStateProvider = ({ children }) => {
+  const [isRecordingStart, setIsRecordingStart] = useState(false);
+  const [isScreenShot, setIsScreenShot] = useState(false);
+
+  return (
+    <GlobalStateContext.Provider
+      value={{
+        isRecordingStart, setIsRecordingStart,
+        isScreenShot, setIsScreenShot
+      }}
+    >
+      {children}
+    </GlobalStateContext.Provider>
+  );
+};
+
+export const useGlobalState = () => useContext(GlobalStateContext);

package/src/Componanats/KeyboardAvoidingWrapper.js

@@ -0,0 +1,43 @@
+import { KeyboardAvoidingView, Platform, TouchableWithoutFeedback, Dimensions, View, ScrollView } from 'react-native'
+import React from 'react'
+
+const KeyboardAvoidingWrapper = ({ children }) => {
+  
+  return (
+    Platform.OS == 'ios' ? (
+      <KeyboardAvoidingView
+        style={{
+          width: '100%',
+          height: '100%'
+        }}
+        behavior={Platform.OS == 'ios' ? 'padding' : 'height'}
+        enabled={false}
+      >
+        <TouchableWithoutFeedback >{children}
+        </TouchableWithoutFeedback>
+      </KeyboardAvoidingView>) : (
+      <KeyboardAvoidingView
+        style={{
+          width: '100%',
+          height: "100%",
+          backgroundColor: "#fff"
+        }}
+        behavior={Platform.OS == 'ios' ? 'padding' : 'height'}
+        keyboardVerticalOffset={Platform.OS === 'android' ? -130 : 0}
+      >
+        <TouchableWithoutFeedback >
+            <View
+              style={{
+                height: '100%',
+                minHeight: Dimensions.get('window').height*0.97,
+              }}
+            >
+              {children}
+            </View>
+        </TouchableWithoutFeedback>
+      </KeyboardAvoidingView>
+    )
+  )
+}
+
+export default KeyboardAvoidingWrapper;

package/src/Componanats/NavigationContext.js

@@ -0,0 +1,42 @@
+// NavigationContext.js
+import React, { createContext, useContext, useState } from 'react';
+import { useFocusEffect } from '@react-navigation/native';
+
+const NavigationContext = createContext();
+
+export const NavigationProvider = ({ children }) => {
+  const [navigationState, setNavigationState] = useState([{name: 'ShakebugHome', params: {} }]);
+
+  const [focusedScreen, setFocusedScreen] = useState('');
+
+  const navigate = (screen, params = {}) => {
+    setNavigationState((prevState) => [...prevState, { name: screen, params }]);
+  };
+
+  const goBack = (steps = 1) => {
+    setNavigationState((prevState) => prevState.slice(0, -steps));
+  };
+
+  const goToScreenAtIndex = (index) => {
+    if (index >= 0 && index < navigationState.length) {
+      setNavigationState((prevState) => prevState.slice(0, index + 1));
+    }
+  };
+
+  useFocusEffect(
+    React.useCallback(() => {
+      setFocusedScreen(navigationState[navigationState.length - 1].name);
+      return () => {
+        setFocusedScreen('');
+      };
+    }, [navigationState])
+  );
+
+  return (
+    <NavigationContext.Provider value={{ navigationState, navigate, goBack, focusedScreen, goToScreenAtIndex}}>
+      {children}
+    </NavigationContext.Provider>
+  );
+};
+
+export const useNavigation = () => useContext(NavigationContext);