ವರ್ಡ್ ಆಫೀಸ್ ಆಡ್-ಆನ್‌ನಲ್ಲಿ ಮೈಕ್ರೋಸಾಫ್ಟ್ ಗ್ರಾಫ್ ಮತ್ತು ಪಿಎನ್‌ಪಿಜೆಗಳನ್ನು ಸರಿಯಾಗಿ ಹೊಂದಿಸುವುದು ಹೇಗೆ

ನಿಮ್ಮ ವರ್ಡ್ ಆಡ್-ಇನ್‌ಗಾಗಿ ಡೇಟಾ ಪ್ರವೇಶವನ್ನು ಸುಗಮಗೊಳಿಸಲಾಗುತ್ತಿದೆ

ಶೇರ್‌ಪಾಯಿಂಟ್ ಡಾಕ್ಯುಮೆಂಟ್ ಲೈಬ್ರರಿಯಿಂದ ನಿರ್ದಿಷ್ಟ ಡೇಟಾವನ್ನು ಎಳೆಯುವ ಅಗತ್ಯವಿರುವ ವರ್ಡ್ ಆಫೀಸ್ ಆಡ್-ಇನ್ ಅನ್ನು ನೀವು ಅಭಿವೃದ್ಧಿಪಡಿಸುತ್ತಿದ್ದೀರಿ ಎಂದು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ. PnPjs ಮತ್ತು ಮೈಕ್ರೋಸಾಫ್ಟ್ ಗ್ರಾಫ್‌ನಂತಹ ಚೌಕಟ್ಟುಗಳನ್ನು ಬಳಸಿ, ಈ ಕಾರ್ಯವು ನೇರವಾಗಿರಬೇಕು. ಆದರೆ ಪ್ರಾರಂಭವು ವಿಫಲವಾದಾಗ, ವಿಷಯಗಳನ್ನು ತ್ವರಿತವಾಗಿ ನಿರಾಶೆಗೊಳಿಸಬಹುದು. 🤔

ನಮ್ಮ ಸನ್ನಿವೇಶದಲ್ಲಿ, ಆಡ್-ಇನ್‌ನಲ್ಲಿ ಬಳಕೆದಾರರ ಸಂವಾದವನ್ನು ಹೆಚ್ಚಿಸಲು ಶೇರ್‌ಪಾಯಿಂಟ್‌ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾದ JSON ಫೈಲ್ ಅನ್ನು ಓದುವ ಗುರಿಯನ್ನು ನಾವು ಹೊಂದಿದ್ದೇವೆ. PnPjs ಮೈಕ್ರೋಸಾಫ್ಟ್ ಗ್ರಾಫ್ ಅನ್ನು ಪ್ರವೇಶಿಸಲು ಅನುಕೂಲಕರವಾದ ಅಮೂರ್ತತೆಗಳನ್ನು ನೀಡುತ್ತದೆ, ಆಫೀಸ್ ಆಡ್-ಇನ್‌ನಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸಲು ಅದನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡುವುದು ಅನನ್ಯ ಸವಾಲುಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ.

ಗ್ರಾಫ್ API ವಿನಂತಿಗಳಿಗಾಗಿ ದೃಢೀಕರಣ ಹೆಡರ್ ಅನ್ನು ಸರಿಯಾಗಿ ಹೊಂದಿಸುವಲ್ಲಿ ನಾವು ಎದುರಿಸಿದ ಮುಖ್ಯ ಸಮಸ್ಯೆಯಾಗಿದೆ. ನಮ್ಮ `authService` ನಿರೀಕ್ಷೆಯಂತೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿದ್ದರೂ ಸಹ, ಟೋಕನ್‌ಗಳನ್ನು ಮೌಲ್ಯೀಕರಿಸಲು ಅಥವಾ ಮೂಲ ಬಳಕೆದಾರರ ಡೇಟಾವನ್ನು ಪಡೆಯುವ ಪ್ರಯತ್ನಗಳು ದೋಷಗಳಿಗೆ ಕಾರಣವಾಗಿವೆ.

ಈ ಲೇಖನದಲ್ಲಿ, ಈ ಸಮಸ್ಯೆಗಳು ಏಕೆ ಸಂಭವಿಸುತ್ತವೆ ಎಂಬುದನ್ನು ನಾವು ಅನ್ವೇಷಿಸುತ್ತೇವೆ ಮತ್ತು PnPjs ಮತ್ತು Microsoft Graph ಅನ್ನು ಪ್ರಾರಂಭಿಸಲು ಕೆಲಸದ ಉದಾಹರಣೆಯನ್ನು ಒದಗಿಸುತ್ತೇವೆ. ನಿಮ್ಮ ಅಭಿವೃದ್ಧಿ ಪ್ರಯಾಣದಲ್ಲಿ ನೀವು ಇದೇ ರೀತಿಯ ಅಡಚಣೆಗಳನ್ನು ಎದುರಿಸಿದರೆ, ಈ ಮಾರ್ಗದರ್ಶಿ ನಿಮಗಾಗಿ ಆಗಿದೆ. ಹಂತ ಹಂತವಾಗಿ ಸಮಸ್ಯೆಯನ್ನು ನಿಭಾಯಿಸೋಣ! 🚀

ಆಫೀಸ್ ಆಡ್-ಇನ್‌ಗಳಲ್ಲಿ PnPjs ಮತ್ತು ಮೈಕ್ರೋಸಾಫ್ಟ್ ಗ್ರಾಫ್‌ನ ಸುವ್ಯವಸ್ಥಿತ ಏಕೀಕರಣ

ವರ್ಡ್ ಆಡ್-ಇನ್‌ಗಾಗಿ ಶೇರ್‌ಪಾಯಿಂಟ್‌ನಿಂದ JSON ಫೈಲ್ ಅನ್ನು ಓದುವ ಸಮಸ್ಯೆಯನ್ನು ನಿಭಾಯಿಸಲು, ಒದಗಿಸಿದ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳು PnPjs ಫ್ರೇಮ್‌ವರ್ಕ್ ಮತ್ತು ಮೈಕ್ರೋಸಾಫ್ಟ್ ಗ್ರಾಫ್ API ನ ಶಕ್ತಿಯನ್ನು ನಿಯಂತ್ರಿಸುತ್ತವೆ. ಪರಿಹಾರವು `ಗ್ರಾಫಿ~ ನಿದರ್ಶನವನ್ನು ಪ್ರಾರಂಭಿಸುವ ಮೂಲಕ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ. ಇದು ಎಲ್ಲಾ ನಂತರದ API ಕರೆಗಳಿಗೆ ಅಡಿಪಾಯವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ, ಮೈಕ್ರೋಸಾಫ್ಟ್ ಗ್ರಾಫ್‌ಗೆ ವಿನಂತಿಗಳನ್ನು ಸರಿಯಾಗಿ ರೂಟ್ ಮಾಡಲಾಗಿದೆ ಮತ್ತು ದೃಢೀಕರಿಸಲಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ. `DefaultInit()` ಕಾನ್ಫಿಗರೇಶನ್ ಅನ್ನು ಬಳಸಿಕೊಳ್ಳುವ ಮೂಲಕ, ಅಭಿವರ್ಧಕರು ಕಸ್ಟಮೈಸೇಶನ್‌ಗಳಿಗೆ ನಮ್ಯತೆಯನ್ನು ಉಳಿಸಿಕೊಂಡು ತಮ್ಮ ಸೆಟಪ್ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಸರಳಗೊಳಿಸಬಹುದು.

ಈ ಅನುಷ್ಠಾನದ ಒಂದು ನಿರ್ಣಾಯಕ ಅಂಶವೆಂದರೆ `on.auth.replace` ವಿಧಾನದ ಬಳಕೆ. ಇದು ಡೀಫಾಲ್ಟ್ ದೃಢೀಕರಣ ಕಾರ್ಯವಿಧಾನವನ್ನು ಬದಲಿಸುತ್ತದೆ, ಪ್ರವೇಶ ಟೋಕನ್‌ಗಳ ಡೈನಾಮಿಕ್ ಇಂಜೆಕ್ಷನ್ ಅನ್ನು ವಿನಂತಿಯ ಹೆಡರ್‌ಗಳಿಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಈ ವಿಧಾನವು ಕಸ್ಟಮ್ `authService` ಮೂಲಕ ಟೋಕನ್‌ಗಳನ್ನು ಪಡೆಯುವ ಮೂಲಕ ಗ್ರಾಫ್ API ಗೆ ಸುರಕ್ಷಿತ ಮತ್ತು ಮಾನ್ಯ ಪ್ರವೇಶವನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಎಂಟರ್‌ಪ್ರೈಸ್ ಸನ್ನಿವೇಶಗಳಲ್ಲಿ ಇದು ವಿಶೇಷವಾಗಿ ಉಪಯುಕ್ತವಾಗಿದೆ, ಅಲ್ಲಿ ದೃಢೀಕರಣ ಕೆಲಸದ ಹರಿವುಗಳಿಗೆ ನಿರ್ದಿಷ್ಟ ಭದ್ರತಾ ಪ್ರೋಟೋಕಾಲ್‌ಗಳ ಅನುಸರಣೆ ಅಗತ್ಯವಿರುತ್ತದೆ. 🔐

`acquireTokenSilent()` ಮತ್ತು `acquireTokenPopup()` ನಂತಹ ಟೋಕನ್ ಹ್ಯಾಂಡ್ಲಿಂಗ್ ವಿಧಾನಗಳ ಸೇರ್ಪಡೆಯು ದೃಢೀಕರಣವು ಬಳಕೆದಾರ ಸ್ನೇಹಿ ಮತ್ತು ದೃಢವಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಈ ವಿಧಾನಗಳು ಆಡ್-ಇನ್ ಅನ್ನು ಮನಬಂದಂತೆ ಕಾರ್ಯನಿರ್ವಹಿಸಲು ಅನುಮತಿಸುತ್ತದೆ, ಸಂಗ್ರಹದಿಂದ ಟೋಕನ್‌ಗಳನ್ನು ಹಿಂಪಡೆಯುತ್ತದೆ ಅಥವಾ ಅಗತ್ಯವಿದ್ದಾಗ ಮಾತ್ರ ಬಳಕೆದಾರರನ್ನು ಪ್ರೇರೇಪಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ವರ್ಡ್‌ನಲ್ಲಿ ಉದ್ಯೋಗಿ ವರದಿಗಳನ್ನು ರಚಿಸುವ ಅಗತ್ಯವಿರುವ HR ಮ್ಯಾನೇಜರ್ ಅನ್ನು ಊಹಿಸಿ. ಆಡ್-ಇನ್ ಹಿನ್ನೆಲೆಯಲ್ಲಿ ಮೌನವಾಗಿ ದೃಢೀಕರಿಸಬಹುದು, ಮ್ಯಾನೇಜರ್‌ನ ಅನುಭವವು ಅಡೆತಡೆಯಿಲ್ಲದೆ ಇರುವುದನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಇದು ಪರಿಹಾರವನ್ನು ಸ್ಕೇಲೆಬಲ್ ಮತ್ತು ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಮಾಡುತ್ತದೆ. 🚀

ಅಂತಿಮವಾಗಿ, ಟೋಕನ್ ಕಾರ್ಯವನ್ನು ಡೀಬಗ್ ಮಾಡಲು ಮತ್ತು ಮೌಲ್ಯೀಕರಿಸಲು `graph.me()` ನಂತಹ API ಪರೀಕ್ಷಾ ಆಜ್ಞೆಗಳ ಏಕೀಕರಣವು ಅತ್ಯಮೂಲ್ಯವಾಗಿದೆ. ಈ ಹಂತವು ಶೇರ್‌ಪಾಯಿಂಟ್ ಡಾಕ್ಯುಮೆಂಟ್‌ಗಳನ್ನು ಓದುವಂತಹ ಹೆಚ್ಚು ಸಂಕೀರ್ಣ ಕಾರ್ಯಾಚರಣೆಗಳಿಗೆ ಧುಮುಕುವ ಮೊದಲು ದೃಢೀಕರಣದ ಹರಿವು ಸರಿಯಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಮಾಡ್ಯುಲಾರಿಟಿ ಮತ್ತು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳನ್ನು ಸಂಯೋಜಿಸುವ ಮೂಲಕ, ಈ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳು ಒಂದೇ ರೀತಿಯ ಸವಾಲುಗಳನ್ನು ನಿಭಾಯಿಸಲು ಸ್ಪಷ್ಟ ಮತ್ತು ಮರುಬಳಕೆ ಮಾಡಬಹುದಾದ ಚೌಕಟ್ಟನ್ನು ಒದಗಿಸುತ್ತವೆ. ನೀವು ವೈಯಕ್ತಿಕ ಬಳಕೆಗಾಗಿ ಆಡ್-ಇನ್ ಅನ್ನು ನಿರ್ಮಿಸುತ್ತಿರಲಿ ಅಥವಾ ಎಂಟರ್‌ಪ್ರೈಸ್-ವೈಡ್ ಪರಿಹಾರಗಳನ್ನು ನಿಯೋಜಿಸುತ್ತಿರಲಿ, ಈ ಸೆಟಪ್ ನಮ್ಯತೆ ಮತ್ತು ವಿಶ್ವಾಸಾರ್ಹತೆ ಎರಡನ್ನೂ ಖಾತರಿಪಡಿಸುತ್ತದೆ.

// Import necessary modules from PnPjs
import { graphfi } from "@pnp/graph";
import "@pnp/graph/users"; // For accessing user data
import { DefaultInit } from "@pnp/graph/presets/all";
// Authentication Service Integration
class AuthService {
    async getGraphApiToken(authority) {
        // Replace this with your actual token fetch logic
        return { accessToken: "your-access-token" };
    }
}
// Main configuration class
class GraphConfig {
    constructor(authService) {
        this.authService = authService;
        this.graph = null;
    }
    async initialize() {
        this.graph = graphfi().using(DefaultInit(), (instance) => {
            instance.on.auth.replace(async (url, context) => {
                const tokenResponse = await this.authService.getGraphApiToken("your-authority");
                if (!tokenResponse) {
                    console.error("Token retrieval failed");
                    return;
                }
                context.headers = {
                    ...context.headers,
                    Authorization: `Bearer ${tokenResponse.accessToken}`
                };
            });
        });
    }
    async testTokenValidity() {
        try {
            const userInfo = await this.graph.me();
            console.log("User info:", userInfo);
        } catch (error) {
            console.error("Token is not valid:", error);
        }
    }
}
// Usage example
const authService = new AuthService();
const graphConfig = new GraphConfig(authService);
await graphConfig.initialize();
await graphConfig.testTokenValidity();

// Import necessary modules
import * as msal from "@azure/msal-browser";
import { graphfi } from "@pnp/graph";
import "@pnp/graph/users";
// MSAL Configuration
const msalConfig = {
    auth: {
        clientId: "your-client-id",
        authority: "https://login.microsoftonline.com/your-tenant-id",
        redirectUri: "your-redirect-uri"
    }
};
// Initialize MSAL client
const msalClient = new msal.PublicClientApplication(msalConfig);
// Acquire token silently or interactively
async function getToken() {
    try {
        const response = await msalClient.acquireTokenSilent({
            scopes: ["https://graph.microsoft.com/.default"]
        });
        return response.accessToken;
    } catch (error) {
        if (error instanceof msal.InteractionRequiredAuthError) {
            const response = await msalClient.acquireTokenPopup({
                scopes: ["https://graph.microsoft.com/.default"]
            });
            return response.accessToken;
        }
        throw error;
    }
}
// Initialize PnPjs with MSAL token
const graph = graphfi().using((instance) => {
    instance.on.auth.replace(async (url, context) => {
        const token = await getToken();
        context.headers = {
            ...context.headers,
            Authorization: `Bearer ${token}`
        };
    });
});
// Test API
async function testApi() {
    try {
        const user = await graph.me();
        console.log("User info:", user);
    } catch (error) {
        console.error("API call failed:", error);
    }
}
// Execute test
testApi();

ಆಫೀಸ್ ಆಡ್-ಇನ್‌ಗಳಲ್ಲಿ ದೃಢೀಕರಣ ಮತ್ತು ಡೇಟಾ ಹಿಂಪಡೆಯುವಿಕೆಯನ್ನು ಉತ್ತಮಗೊಳಿಸುವುದು

ಪ್ರಾಥಮಿಕ ಸವಾಲು PnPjs ಅನ್ನು ಪ್ರಾರಂಭಿಸುವುದರ ಸುತ್ತ ಸುತ್ತುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ಮೈಕ್ರೋಸಾಫ್ಟ್ ಗ್ರಾಫ್‌ನೊಂದಿಗೆ ಸಂಯೋಜಿಸುತ್ತದೆ, ಅಷ್ಟೇ ನಿರ್ಣಾಯಕ ಅಂಶವೆಂದರೆ ದೃಢೀಕರಣವನ್ನು ಸುರಕ್ಷಿತವಾಗಿ ಮತ್ತು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ನಿರ್ವಹಿಸುವುದು. ಆಫೀಸ್ ಆಡ್-ಇನ್‌ಗಳಿಗಾಗಿ, MSAL.js ಲೈಬ್ರರಿ ಅನ್ನು ಬಳಸುವುದು ಟೋಕನ್ ಸ್ವಾಧೀನವನ್ನು ಸರಳಗೊಳಿಸುತ್ತದೆ, ವಿಶೇಷವಾಗಿ ಬಹು-ಹಿಡುವಳಿದಾರರು ಅಥವಾ ಎಂಟರ್‌ಪ್ರೈಸ್ ಸನ್ನಿವೇಶಗಳನ್ನು ನಿರ್ವಹಿಸುವಾಗ. MSAL ಬಳಕೆದಾರರ ದೃಢೀಕರಣವನ್ನು ಸುವ್ಯವಸ್ಥಿತಗೊಳಿಸುವ ವಿಧಾನಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ, ಸಂಕೀರ್ಣ ಬ್ಯಾಕೆಂಡ್ ಸೇವೆಗಳ ಅಗತ್ಯವನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ, ಇದು ಹಗುರವಾದ ವರ್ಡ್ ಆಡ್-ಇನ್‌ಗಳನ್ನು ನಿಯೋಜಿಸುವಾಗ ಮುಖ್ಯವಾಗಿದೆ. 🔑

ಮತ್ತೊಂದು ಪ್ರಮುಖ ಪರಿಗಣನೆಯು ದೋಷ ಸ್ಥಿತಿಗಳು ಮತ್ತು ಟೋಕನ್ ಮುಕ್ತಾಯವನ್ನು ನಿರ್ವಹಿಸುವುದು. ಆಫೀಸ್ ಆಡ್-ಇನ್‌ಗಳು ಕಟ್ಟುನಿಟ್ಟಾದ ಸಮಯ ಮಿತಿಗಳು ಮತ್ತು ಭದ್ರತಾ ನೀತಿಗಳೊಂದಿಗೆ ಪರಿಸರದಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ. ಬಳಕೆದಾರರ ನಂಬಿಕೆ ಮತ್ತು ಡೇಟಾ ಸುರಕ್ಷತೆಯನ್ನು ಕಾಪಾಡಿಕೊಳ್ಳಲು, ವಿಫಲವಾದ ಟೋಕನ್ ವಿನಂತಿಗಳು ಅಥವಾ ಗ್ರಾಫ್ API ಕರೆಗಳಿಗೆ ಮರುಪ್ರಯತ್ನ ಕಾರ್ಯವಿಧಾನಗಳನ್ನು ಅಳವಡಿಸುವುದು ಅತ್ಯಗತ್ಯ. ನೆಟ್‌ವರ್ಕ್ ಅಡೆತಡೆಗಳು ಅಥವಾ ಅವಧಿ ಮೀರಿದ ಟೋಕನ್‌ಗಳನ್ನು ಎದುರಿಸುವಾಗಲೂ ಆಡ್-ಇನ್ ಕಾರ್ಯನಿರ್ವಹಿಸುವುದನ್ನು ಇದು ಖಚಿತಪಡಿಸುತ್ತದೆ, ಪರಿಹಾರದ ಒಟ್ಟಾರೆ ವಿಶ್ವಾಸಾರ್ಹತೆಯನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಸರ್ವರ್ ಸ್ಥಗಿತದ ಸಮಯದಲ್ಲಿ ಡಾಕ್ಯುಮೆಂಟ್ ಅನ್ನು ಪ್ರವೇಶಿಸುವ ಉದ್ಯೋಗಿ ಇನ್ನೂ ಕ್ಯಾಶ್ ಮಾಡಲಾದ ಡೇಟಾವನ್ನು ವೀಕ್ಷಿಸಬಹುದು ಅಥವಾ ಅದನ್ನು ಮನಬಂದಂತೆ ತರಲು ಮರುಪ್ರಯತ್ನಿಸಬಹುದು. 🚀

ಕೊನೆಯದಾಗಿ, ಶೇರ್‌ಪಾಯಿಂಟ್ ಡೇಟಾ ಹಿಂಪಡೆಯುವಿಕೆಯ ಕಾರ್ಯಕ್ಷಮತೆಯು ಮತ್ತೊಂದು ಪ್ರಮುಖ ಪರಿಗಣನೆಯಾಗಿದೆ. ಆಡ್-ಇನ್‌ಗಳು ಬಾಹ್ಯ API ಗಳನ್ನು ಅವಲಂಬಿಸಿರುವುದರಿಂದ, ಸುಪ್ತತೆಯನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಕರೆಗಳನ್ನು ಆಪ್ಟಿಮೈಜ್ ಮಾಡುವುದು ಬಹಳ ಮುಖ್ಯ. ಬ್ಯಾಚಿಂಗ್ ವಿನಂತಿಗಳು ಅಥವಾ ಗ್ರಾಫ್ API ನ ಆಯ್ದ ಗುಣಲಕ್ಷಣಗಳಂತಹ ತಂತ್ರಗಳು ಅಗತ್ಯ ಡೇಟಾವನ್ನು ಮಾತ್ರ ಪಡೆದುಕೊಳ್ಳಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ, ಲೋಡ್ ಸಮಯ ಮತ್ತು ಬ್ಯಾಂಡ್‌ವಿಡ್ತ್ ಬಳಕೆಯನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ. JSON ಫೈಲ್ ಅನ್ನು ಓದುತ್ತಿರಲಿ ಅಥವಾ ಬಳಕೆದಾರರ ಡೇಟಾವನ್ನು ಪಡೆಯುತ್ತಿರಲಿ, ಈ ಆಪ್ಟಿಮೈಸೇಶನ್‌ಗಳು ಹೆಚ್ಚಿನ ಬೇಡಿಕೆಯ ಪರಿಸರದಲ್ಲಿಯೂ ಸಹ ಆಡ್-ಇನ್ ಅನ್ನು ವೇಗವಾಗಿ ಮತ್ತು ಹೆಚ್ಚು ಸ್ಪಂದಿಸುವಂತೆ ಮಾಡುತ್ತದೆ.