Skip to content
TheChatArchiveThe Chat Archive
o1-mini-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

i want a chrome extension that launches from a link i can paste in a youtube video…

  1. User

    i want a chrome extension that launches from a link i can paste in a youtube video description. it should load a popup window when launched. the popup window should stack two youtube videos on top of each other then have a button bellow both. the urls to the two videos are the current url on the page and the next link in the description. the popup window should have no gui at all except for the videos and the minimize, fullscreen, and exit controls, and the one button.

  2. Assistant

    Creating a Chrome extension that launches from a link in a YouTube video description and displays a popup window stacking two YouTube videos with a button involves several steps. Below is a comprehensive guide to help you build this extension.

    Overview of the Steps:

    1. Set Up the Extension Structure
    2. Create the manifest.json File
    3. Develop the Popup HTML and CSS
    4. Implement the Popup JavaScript
    5. Handle Link Activation from YouTube Description
    6. Package and Install the Extension

    1. Set Up the Extension Structure

    Create a new directory for your Chrome extension, for example, youtube-video-stack-extension, and inside it, create the following files:

    • manifest.json
    • popup.html
    • popup.css
    • popup.js
    • background.js
    • icon.png (optional, for extension icon)

    2. Create the manifest.json File

    The manifest.json file tells Chrome about your extension, its permissions, and the files it uses.

    {
      "manifest_version": 3,
      "name": "YouTube Video Stack",
      "version": "1.0",
      "description": "Stacks two YouTube videos in a popup window with a button.",
      "permissions": [
        "activeTab",
        "scripting",
        "tabs"
      ],
      "action": {
        "default_popup": "popup.html",
        "default_icon": "icon.png"
      },
      "background": {
        "service_worker": "background.js"
      },
      "icons": {
        "16": "icon.png",
        "48": "icon.png",
        "128": "icon.png"
      }
    }
    

    Explanation:

    • manifest_version: Specifies the version of the manifest file format.
    • permissions:
      • activeTab: Allows the extension to access the currently active tab when the user interacts with the extension.
      • scripting: Allows the extension to inject scripts into web pages.
      • tabs: Grants the extension access to the browser's tab system.
    • action: Defines the default popup and icon for the extension.
    • background: Specifies the background service worker script.
    • icons: Defines icons for various sizes.

    3. Develop the Popup HTML and CSS

    popup.html

    <!DOCTYPE html>
    <html lang="en">
    <head>
      <meta charset="UTF-8">
      <title>YouTube Video Stack</title>
      <link rel="stylesheet" href="popup.css">
    </head>
    <body>
      <div class="video-container">
        <iframe id="video1" src="" frameborder="0" allowfullscreen></iframe>
        <iframe id="video2" src="" frameborder="0" allowfullscreen></iframe>
      </div>
      <button id="actionButton">Click Me</button>
    
      <script src="popup.js"></script>
    </body>
    </html>
    

    popup.css

    body {
      margin: 0;
      padding: 10px;
      width: 800px;
      height: 600px;
      box-sizing: border-box;
      display: flex;
      flex-direction: column;
      align-items: center;
      background-color: #000;
    }
    
    .video-container {
      display: flex;
      flex-direction: column;
      width: 100%;
      flex-grow: 1;
    }
    
    iframe {
      width: 100%;
      height: 45%;
      margin-bottom: 5%;
    }
    
    button {
      padding: 10px 20px;
      font-size: 16px;
      cursor: pointer;
    }
    

    Explanation:

    • HTML Structure: Two <iframe> elements to embed YouTube videos and a button below them.
    • CSS Styling: Ensures that the videos stack vertically and the popup has a clean, minimalistic design.

    4. Implement the Popup JavaScript

    popup.js

    document.addEventListener('DOMContentLoaded', async () => {
      // Get the current active tab URL
      let [tab] = await chrome.tabs.query({ active: true, currentWindow: true });
      let currentUrl = tab.url;
    
      // Extract the next link from the YouTube description
      // This assumes that the next link is passed via query parameters or another method
      // For simplicity, we'll assume it's provided as a URL parameter named 'next'
    
      const urlParams = new URLSearchParams(tab.url.split('?')[1]);
      const nextUrl = urlParams.get('next');
    
      // Set the iframe sources
      document.getElementById('video1').src = `https://www.youtube.com/embed/${getYouTubeID(currentUrl)}`;
      if (nextUrl) {
        document.getElementById('video2').src = `https://www.youtube.com/embed/${getYouTubeID(nextUrl)}`;
      } else {
        document.getElementById('video2').src = "";
      }
    
      // Handle button click
      document.getElementById('actionButton').addEventListener('click', () => {
        // Define the button's action here
        alert('Button Clicked!');
      });
    });
    
    // Utility function to extract YouTube Video ID
    function getYouTubeID(url) {
      const regExp = /^.*((youtu.be\/)|(v\/)|(\/u\/\w\/)|(embed\/)|(watch\?))\??v?=?([^#&?]*).*/;
      const match = url.match(regExp);
      return (match && match[7].length === 11) ? match[7] : null;
    }
    

    Explanation:

    • Extract Current URL: Retrieves the URL of the currently active tab.
    • Extract Next URL: Assumes the next URL is passed as a query parameter named next. You may need to adjust this based on how you plan to pass the additional URL.
    • Set Iframe Sources: Embeds the two YouTube videos using their video IDs.
    • Button Action: Currently set to display an alert. You can customize this to perform any desired action.

    5. Handle Link Activation from YouTube Description

    To launch the extension from a link in the YouTube description, you can use a custom URL scheme or deep linking approach. However, Chrome extensions cannot be directly invoked via standard http or https links in descriptions due to security restrictions.

    Alternative Approach: Using a Webpage

    1. Create a Webpage: Host a simple webpage that communicates with your extension.

    2. Extension URL Handling: Use the chrome.runtime API to listen for messages from the webpage and trigger the popup.

    background.js

    chrome.runtime.onMessageExternal.addListener(
      (request, sender, sendResponse) => {
        if (request.action === "launchPopup") {
          chrome.windows.create({
            url: chrome.runtime.getURL("popup.html"),
            type: "popup",
            width: 820,
            height: 650
          });
          sendResponse({status: "Popup Launched"});
        }
      }
    );
    

    Explanation:

    • onMessageExternal Listener: Listens for messages from external webpages.
    • Launch Popup: Opens the popup.html as a separate popup window when the action is launchPopup.

    Webpage Scripts

    On your hosted webpage (which you can link in the YouTube description), include a script that sends a message to the extension to launch the popup.

    <!DOCTYPE html>
    <html lang="en">
    <head>
      <meta charset="UTF-8">
      <title>Launch YouTube Video Stack</title>
    </head>
    <body>
      <script>
        // Replace with your extension's ID
        const extensionId = "YOUR_EXTENSION_ID_HERE";
    
        // Function to send message to extension
        function launchExtensionPopup() {
          chrome.runtime.sendMessage(extensionId, { action: "launchPopup" }, response => {
            if (chrome.runtime.lastError) {
              console.error(chrome.runtime.lastError);
            } else {
              console.log(response.status);
            }
          });
        }
    
        // Automatically launch the popup on page load
        window.onload = launchExtensionPopup;
      </script>
    </body>
    </html>
    

    Important Notes:

    • Extension ID: Replace "YOUR_EXTENSION_ID_HERE" with the actual ID of your Chrome extension. You can find this in chrome://extensions/ after installing your extension as an unpacked extension.
    • CORS and Permissions: Ensure your extension's manifest.json includes the externally_connectable field to allow messages from your hosted webpage.

    Update manifest.json

    Add the following to your manifest.json to specify which webpages can communicate with your extension:

    "externally_connectable": {
      "matches": ["https://yourdomain.com/*"]
    },
    

    Replace https://yourdomain.com/* with the actual domain where you host your webpage.

    Final manifest.json Example:

    {
      "manifest_version": 3,
      "name": "YouTube Video Stack",
      "version": "1.0",
      "description": "Stacks two YouTube videos in a popup window with a button.",
      "permissions": [
        "activeTab",
        "scripting",
        "tabs"
      ],
      "action": {
        "default_popup": "popup.html",
        "default_icon": "icon.png"
      },
      "background": {
        "service_worker": "background.js"
      },
      "icons": {
        "16": "icon.png",
        "48": "icon.png",
        "128": "icon.png"
      },
      "externally_connectable": {
        "matches": ["https://yourdomain.com/*"]
      }
    }
    

    Hosting the Webpage:

    • Host the webpage (HTML file) on a server you control.
    • In your YouTube video description, add a link to this webpage.

    Example YouTube Description Link:

    [Watch Videos in Stack](https://yourdomain.com/launch.html?next=NEXT_VIDEO_URL)
    

    Passing the Next Video URL:

    Modify the webpage script to extract the next parameter from the URL and pass it to the extension.

    Updated launch.html Script:

    <!DOCTYPE html>
    <html lang="en">
    <head>
      <meta charset="UTF-8">
      <title>Launch YouTube Video Stack</title>
    </head>
    <body>
      <script>
        // Replace with your extension's ID
        const extensionId = "YOUR_EXTENSION_ID_HERE";
    
        // Function to send message to extension
        function launchExtensionPopup(nextVideoUrl) {
          chrome.runtime.sendMessage(extensionId, { action: "launchPopup", next: nextVideoUrl }, response => {
            if (chrome.runtime.lastError) {
              console.error(chrome.runtime.lastError);
            } else {
              console.log(response.status);
            }
          });
        }
    
        // Extract 'next' parameter from URL
        const urlParams = new URLSearchParams(window.location.search);
        const nextVideoUrl = urlParams.get('next');
    
        // Automatically launch the popup on page load
        window.onload = () => {
          launchExtensionPopup(nextVideoUrl);
        };
      </script>
    </body>
    </html>
    

    Update background.js to Handle next Parameter:

    chrome.runtime.onMessageExternal.addListener(
      (request, sender, sendResponse) => {
        if (request.action === "launchPopup") {
          const nextUrl = request.next;
          chrome.windows.create({
            url: `${chrome.runtime.getURL("popup.html")}?next=${encodeURIComponent(nextUrl)}`,
            type: "popup",
            width: 820,
            height: 650
          });
          sendResponse({status: "Popup Launched"});
        }
      }
    );
    

    Update popup.js to Receive next Parameter:

    document.addEventListener('DOMContentLoaded', () => {
      // Get the current active tab URL
      chrome.tabs.query({ active: true, currentWindow: true }, (tabs) => {
        let currentUrl = tabs[0].url;
    
        // Extract 'next' parameter from popup URL
        const urlParams = new URLSearchParams(window.location.search);
        const nextUrl = urlParams.get('next');
    
        // Set the iframe sources
        const video1Id = getYouTubeID(currentUrl);
        const video2Id = nextUrl ? getYouTubeID(nextUrl) : null;
    
        if (video1Id) {
          document.getElementById('video1').src = `https://www.youtube.com/embed/${video1Id}`;
        }
    
        if (video2Id) {
          document.getElementById('video2').src = `https://www.youtube.com/embed/${video2Id}`;
        } else {
          document.getElementById('video2').style.display = 'none';
        }
      });
    
      // Handle button click
      document.getElementById('actionButton').addEventListener('click', () => {
        // Define the button's action here
        alert('Button Clicked!');
      });
    });
    
    // Utility function to extract YouTube Video ID
    function getYouTubeID(url) {
      const regExp = /^.*((youtu.be\/)|(v\/)|(\/u\/\w\/)|(embed\/)|(watch\?))\??v?=?([^#&?]*).*/;
      const match = url.match(regExp);
      return (match && match[7].length === 11) ? match[7] : null;
    }
    

    6. Package and Install the Extension

    1. Load the Unpacked Extension:

      • Open Chrome and navigate to chrome://extensions/.
      • Enable "Developer mode" using the toggle in the top right corner.
      • Click "Load unpacked" and select your extension's directory (youtube-video-stack-extension).
    2. Test the Extension:

      • Ensure your hosted webpage is accessible.
      • In your YouTube video description, add the link to the hosted webpage with the next parameter.

      Example:

      [Watch Videos in Stack](https://yourdomain.com/launch.html?next=https://www.youtube.com/watch?v=NEXT_VIDEO_ID)
      
    3. Usage:

      • View the YouTube video.
      • Click the link in the description.
      • The hosted webpage will communicate with your extension to launch the popup with the stacked videos.

    Important Considerations:

    • Security Restrictions:

      • Chrome extensions cannot be directly invoked from standard web links without using messaging APIs.
      • Ensure you handle permissions securely and only allow trusted webpages to communicate with your extension.
    • User Permissions:

      • Inform users about the permissions your extension requires and why.
    • YouTube Policies:

      • Ensure that your extension complies with YouTube's terms of service, especially when embedding videos and interacting with YouTube content.
    • Error Handling:

      • Implement proper error handling for cases where the next URL is invalid or missing.
    • Enhancements:

      • Allow customization of the button's action.
      • Implement responsive design for the popup window to handle different screen sizes.

    By following this guide, you should be able to create a Chrome extension that meets your specifications. Remember to test thoroughly and adhere to best practices for Chrome extension development and web security.