Working with Network and API

const response = await fetch('https://api.example.com/users');
const data = await response.json();
console.log(data);

const newUser = {
  name: 'Jane Doe',
  email: 'jane@example.com'
};

const response = await fetch('https://api.example.com/users', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json'
  },
  body: JSON.stringify(newUser)
});

const result = await response.json();
console.log(result);

import { useState, useEffect } from 'react';
import { fetch } from 'expo';

export default function UserProfile() {
  const [userData, setUserData] = useState(null);
  const [loading, setLoading] = useState(true);

  useEffect(() => {
    fetch('https://api.example.com/user/123')
      .then(response => response.json())
      .then(data => {
        setUserData(data);
        setLoading(false);
      })
      .catch(error => {
        console.error('Error fetching user data:', error);
        setLoading(false);
      });
  }, []);

  if (loading) return <div>Loading...</div>;
  return <div>Hello, {userData.name}!</div>;
}

import { fetch } from "expo";

const postData = {
  name: "John",
  age: 30
};

const response = await fetch("https://api.example.com/users", {
  method: "POST",
  headers: {
    "Content-Type": "application/json"
  },
  body: JSON.stringify(postData)
});

console.log("Response:", response);

fetch('https://api.example.com/data', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer <token>',
    'Content-Type': 'application/json',
    'Accept': 'application/json'
  }
})
.then(response => response.json())
.then(data => console.log(data));

import axios from 'axios';

const fetchData = async () => {
  try {
    const response = await axios.get('https://jsonplaceholder.typicode.com/posts/1');
    console.log(response.data);
  } catch (error) {
    console.error('Error fetching data:', error);
  }
};

fetchData();

import axios from 'axios';

const postData = async () => {
  try {
    const response = await axios.post('https://jsonplaceholder.typicode.com/posts', {
      title: 'My New Post',
      body: 'This is the content of my post.',
      userId: 1
    });
    console.log('Created:', response.data);
  } catch (error) {
    console.error('Error posting data:', error);
  }
};

postData();

import axios from 'axios';

const instance = axios.create({
  baseURL: 'https://api.example.com'
});

instance.interceptors.request.use(
  (config) => {
    const token = localStorage.getItem('authToken');
    if (token) {
      config.headers.Authorization = `Bearer ${token}`;
    }
    return config;
  },
  (error) => {
    return Promise.reject(error);
  }
);

instance.interceptors.response.use(
  (response) => {
    console.log('Response received:', response);
    return response;
  },
  (error) => {
    if (error.response?.status === 401) {
      // Redirect to login or refresh token
      console.log('Unauthorized, redirecting...');
    }
    return Promise.reject(error);
  }
);

import { Network } from 'expo-network';

export default function NetworkStatus() {
  const [networkState, setNetworkState] = useState(null);

  useEffect(() => {
    const checkNetwork = async () => {
      const state = await Network.getNetworkStateAsync();
      setNetworkState(state);
    };

    checkNetwork();
  }, []);

  return (
    <View style={styles.container}>
      <Text>Network Type: {networkState?.type || &#x27;Unknown&#x27;}</Text>
      <Text>Is Connected: {networkState?.isConnected ? &#x27;Yes&#x27; : &#x27;No&#x27;}</Text>
    </View>
  );
}

import { Network } from 'expo-network';

const handleNetworkChange = (networkState) => {
  console.log("Network changed:", networkState);
};

Network.addEventListener("networkStateChange", handleNetworkChange);

// Don't forget to remove listener when component unmounts
useEffect(() => {
  return () => {
    Network.removeEventListener("networkStateChange", handleNetworkChange);
  };
}, []);

import * as WebSocket from 'ws';

const ws = new WebSocket("wss://example.com/websocket");

ws.on("open", () => {
  console.log("Connected to WebSocket server");
});

ws.on("message", (data) => {
  console.log("Received:", data);
});

ws.on("close", () => {
  console.log("WebSocket connection closed");
});

const message = {
  type: "chat",
  content: "Hello, server!"
};

ws.send(JSON.stringify(message));

import { ApolloClient, InMemoryCache, ApolloProvider, useQuery } from '@apollo/client';
import { gql } from 'graphql-tag';

const client = new ApolloClient({
  uri: 'https://your-graphql-endpoint.com/graphql',
  cache: new InMemoryCache()
});

const GET_POSTS = gql`
  query GetPosts {
    posts {
      id
      title
      content
    }
  }
`;

function PostsList() {
  const { loading, error, data } = useQuery(GET_POSTS);

  if (loading) return <p>Loading...</p>;
  if (error) return <p>Error: {error.message}</p>;

  return (
    <ul>
      {data.posts.map(post => (
        <li key={post.id}>{post.title}</li>
      ))}
    </ul>
  );
}

import { cache } from 'expo-api';\n\nconst response = await cache.fetch('https://api.example.com/data', {\n  cacheTTL: 60000,\n  method: 'GET'\n});