Cum să faci un plugin să depindă de alt plugin?

Începând cu versiunea 6.5 a WordPress, puteți defini dependențele de plugin-uri în fișierul principal al plugin-ului folosind antetul Requires Plugins. De exemplu:

/**
 * Plugin Name: Pluginul meu
 * Requires Plugins: plugin-unu, plugin-doi
 */

Pur și simplu adăugați o listă separată prin virgulă a slug-urilor plugin-urilor din depozitul WP.org, și sunteți gata.

Dependențele sunt listate în cardul plugin-ului în sine, în ecranele Plugin-uri → Toate plugin-urile și Plugin-uri → Adaugă noi.

Plugin-urile care nu sunt găzduite pe WordPress.org pot fi de asemenea listate, dar acestea trebuie instalate manual.

Rețineți că această funcționalitate nu funcționează pentru teme, ci doar pentru plugin-uri. De asemenea, nu puteți defini versiuni specifice ale plugin-urilor, iar toate plugin-urile vor fi obligatorii. Nu există nicio posibilitate de a cere doar unul dintre plugin-urile listate.

Citiți întregul anunț despre această funcționalitate în articolul de pe blogul make.wordpress.org.

Ambele soluții propuse au deficiențe.

Metoda 1: După cum s-a menționat, ecranul wp_die() VA APĂREA în continuare atunci când Plugin-ul Părinte și Plugin-ul Copil sunt activate simultan folosind casetele de selectare din panoul de administrare al plugin-urilor.

Metoda 2: În unele cazuri de utilizare nu este bună deoarece 'admin_init' este executat mult după 'plugins_loaded' (https://codex.wordpress.org/Plugin_API/Action_Reference), și după hook-ul de dezinstalare (https://codex.wordpress.org/Function_Reference/register_uninstall_hook). De exemplu, dacă dorim ca add-on-ul să execute un cod la dezinstalare, indiferent dacă plugin-ul părinte este activ sau nu, această abordare NU va funcționa.

Soluție:

În primul rând, trebuie să adăugăm următorul cod la sfârșitul fișierului PHP principal al plugin-ului părinte:

do_action( 'my_plugin_loaded' );

Acest lucru va trimite un eveniment/semnal tuturor abonaților, anunțând că plugin-ul principal a fost încărcat.

Apoi, clasa add-on-ului ar trebui să arate astfel:

class My_Addon
{
    static function init ()
    {
        register_activation_hook( __FILE__, array( __CLASS__, '_install' ) );

        if ( ! self::_is_parent_active_and_loaded() ) {
            return;
        }
    }

    #region Parent Plugin Check

    /**
     * Verifică dacă plugin-ul părinte este activat (nu neapărat încărcat).
     *
     * @author Vova Feldman (@svovaf)
     *
     * @return bool
     */
    static function _is_parent_activated()
    {
        $active_plugins_basenames = get_option( 'active_plugins' );
        foreach ( $active_plugins_basenames as $plugin_basename ) {
            if ( false !== strpos( $plugin_basename, '/my-plugin-main-file.php' ) ) {
                return true;
            }
        }

        return false;
    }

    /**
     * Verifică dacă plugin-ul părinte este activ și încărcat.
     *
     * @author Vova Feldman (@svovaf)
     *
     * @return bool
     */
    static function _is_parent_active_and_loaded()
    {
        return class_exists( 'My_Plugin' );
    }

    /**
     *
     * @author Vova Feldman (@svovaf)
     */
    static function _install()
    {
        if ( ! self::_is_parent_active_and_loaded() ) {
            deactivate_plugins( basename( __FILE__ ) );

            // Mesaj de eroare + link de întoarcere.
            wp_die( __( 'My Add-on necesită My Plugin să fie instalat și activat.' ), __( 'Eroare' ), array( 'back_link' => true ) );
        }
    }

    #endregion Parent Plugin Check
}

if (My_Addon::_is_parent_active_and_loaded())
{
    // Dacă plugin-ul părinte este deja inclus, inițializează add-on-ul.
    My_Addon::init();
}
else if (My_Addon::_is_parent_activated())
{
    // Inițializează add-on-ul numai după ce plugin-ul părinte este încărcat.
    add_action( 'my_plugin_loaded', array( __CLASS__, 'init' ) );
}
else
{
    // Chiar dacă plugin-ul părinte nu este activat, execută add-on-ul pentru hook-urile de activare / dezinstalare.
    My_Addon::init();
}

Sper că vă ajută :)

Încearcă asta, este comentat, așa că ar trebui să te ajute să înțelegi.

<?php
register_activation_hook( __FILE__, 'myplugin_activate' ); // Înregistrează funcția myplugin_activate
function myplugin_activate() {
    $plugin = plugin_basename( __FILE__ ); // 'myplugin'
    if ( is_plugin_active( 'plugin-directory/first-plugin.php' ) ) {
        // Plugin-ul era activ, execută hook-ul pentru 'myplugin'
    } else {
        // Plugin-ul nu era activ, oh nu, nu permite activarea acestui plugin
        deactivate_plugins( $plugin ); // Dezactivează 'myplugin'
    }
}
?> 

Dacă acest cod generează o eroare, ai putea verifica și 'option' pentru 'myplugin' și să îl setezi pe false sau neactivat.

Cred că ai nevoie de TGM Plugin Activation.

TGM Plugin Activation este o bibliotecă PHP care îți permite să ceri sau să recomanzi cu ușurință pluginuri pentru temele WordPress (și pluginuri). Le permite utilizatorilor tăi să instaleze, să actualizeze și chiar să activeze automat pluginuri în mod singular sau în masă folosind clasele, funcțiile și interfețele native WordPress. Poți face referire la pluginuri incluse, pluginuri din Depozitul de Pluginuri WordPress sau chiar pluginuri găzduite în altă parte pe internet.