카카오 소셜로그인 창띄울때 언어팩이 영어로 뜹니다

1

현재 그누보드5에 내장되어 있는 소셜로그인을 쓰고 있습니다.
Auth.php – 아래코드

<?php

/**
 * HybridAuth
 * http://hybridauth.sourceforge.net | http://github.com/hybridauth/hybridauth
 * (c) 2009-2015, HybridAuth authors | http://hybridauth.sourceforge.net/licenses.html
 */

/**
 * Hybrid_Auth class
 *
 * Hybrid_Auth class provide a simple way to authenticate users via OpenID and OAuth.
 *
 * Generally, Hybrid_Auth is the only class you should instanciate and use throughout your application.
 */
class Hybrid_Auth {

	public static $version = "2.9.6";

	/**
	 * Configuration array
	 * @var array
	 */
	public static $config = array();

	/**
	 * Auth cache
	 * @var Hybrid_Storage
	 */
	public static $store = null;

	/**
	 * Error pool
	 * @var Hybrid_Error
	 */
	public static $error = null;

	/**
	 * Logger
	 * @var Hybrid_Logger
	 */
	public static $logger = null;

	/**
	 * Try to start a new session of none then initialize Hybrid_Auth
	 *
	 * Hybrid_Auth constructor will require either a valid config array or
	 * a path for a configuration file as parameter. To know more please
	 * refer to the Configuration section:
	 * http://hybridauth.sourceforge.net/userguide/Configuration.html
	 *
	 * @param array $config Configuration array or path to a configratuion file
	 */
	function __construct($config) {
		Hybrid_Auth::initialize($config);
	}

	/**
	 * Try to initialize Hybrid_Auth with given $config hash or file
	 *
	 * @param array $config Configuration array or path to a configratuion file
	 * @return void
	 * @throws Exception
	 */
	public static function initialize($config) {
		if (!is_array($config) && !file_exists($config)) {
			throw new Exception("Hybriauth config does not exist on the given path.", 1);
		}

		if (!is_array($config)) {
			$config = include $config;
		}

		// build some need'd paths
		$config["path_base"] = realpath(dirname(__FILE__)) . "/";
		$config["path_libraries"] = $config["path_base"] . "thirdparty/";
		$config["path_resources"] = $config["path_base"] . "resources/";
		$config["path_providers"] = $config["path_base"] . "Providers/";

		// reset debug mode
		if (!isset($config["debug_mode"])) {
			$config["debug_mode"] = false;
			$config["debug_file"] = null;
		}

		# load hybridauth required files, a autoload is on the way...
		require_once $config["path_base"] . "Error.php";
		require_once $config["path_base"] . "Exception.php";
		require_once $config["path_base"] . "Logger.php";

		require_once $config["path_base"] . "Provider_Adapter.php";

		require_once $config["path_base"] . "Provider_Model.php";
		require_once $config["path_base"] . "Provider_Model_OpenID.php";
		require_once $config["path_base"] . "Provider_Model_OAuth1.php";
		require_once $config["path_base"] . "Provider_Model_OAuth2.php";

		require_once $config["path_base"] . "User.php";
		require_once $config["path_base"] . "User_Profile.php";
		require_once $config["path_base"] . "User_Contact.php";
		require_once $config["path_base"] . "User_Activity.php";

		if (!class_exists("Hybrid_Storage", false)) {
			require_once $config["path_base"] . "Storage.php";
		}

		// hash given config
		Hybrid_Auth::$config = $config;

		// instance of log mng
		Hybrid_Auth::$logger = new Hybrid_Logger();

		// instance of errors mng
		Hybrid_Auth::$error = new Hybrid_Error();

		// start session storage mng
		Hybrid_Auth::$store = new Hybrid_Storage();

		Hybrid_Logger::info("Enter Hybrid_Auth::initialize()");
		Hybrid_Logger::info("Hybrid_Auth::initialize(). PHP version: " . PHP_VERSION);
		Hybrid_Logger::info("Hybrid_Auth::initialize(). Hybrid_Auth version: " . Hybrid_Auth::$version);
		Hybrid_Logger::info("Hybrid_Auth::initialize(). Hybrid_Auth called from: " . Hybrid_Auth::getCurrentUrl());

		// PHP Curl extension [http://www.php.net/manual/en/intro.curl.php]
		if (!function_exists('curl_init')) {
			Hybrid_Logger::error('Hybridauth Library needs the CURL PHP extension.');
			throw new Exception('Hybridauth Library needs the CURL PHP extension.');
		}

		// PHP JSON extension [http://php.net/manual/en/book.json.php]
		if (!function_exists('json_decode')) {
			Hybrid_Logger::error('Hybridauth Library needs the JSON PHP extension.');
			throw new Exception('Hybridauth Library needs the JSON PHP extension.');
		}

		// session.name
		if (session_name() != "PHPSESSID") {
			Hybrid_Logger::info('PHP session.name diff from default PHPSESSID. http://php.net/manual/en/session.configuration.php#ini.session.name.');
		}

		// safe_mode is on
		if (ini_get('safe_mode')) {
			Hybrid_Logger::info('PHP safe_mode is on. http://php.net/safe-mode.');
		}

		// open basedir is on
		if (ini_get('open_basedir')) {
			Hybrid_Logger::info('PHP open_basedir is on. http://php.net/open-basedir.');
		}

		Hybrid_Logger::debug("Hybrid_Auth initialize. dump used config: ", serialize($config));
		Hybrid_Logger::debug("Hybrid_Auth initialize. dump current session: ", Hybrid_Auth::storage()->getSessionData());
		Hybrid_Logger::info("Hybrid_Auth initialize: check if any error is stored on the endpoint...");

		if (Hybrid_Error::hasError()) {
			$m = Hybrid_Error::getErrorMessage();
			$c = Hybrid_Error::getErrorCode();
			$p = Hybrid_Error::getErrorPrevious();

			Hybrid_Logger::error("Hybrid_Auth initialize: A stored Error found, Throw an new Exception and delete it from the store: Error#$c, '$m'");

			Hybrid_Error::clearError();

			// try to provide the previous if any
			// Exception::getPrevious (PHP 5 >= 5.3.0) http://php.net/manual/en/exception.getprevious.php
			if (version_compare(PHP_VERSION, '5.3.0', '>=') && ($p instanceof Exception)) {
				throw new Exception($m, $c, $p);
			} else {
				throw new Exception($m, $c);
			}
		}

		Hybrid_Logger::info("Hybrid_Auth initialize: no error found. initialization succeed.");
	}

	/**
	 * Hybrid storage system accessor
	 *
	 * Users sessions are stored using HybridAuth storage system ( HybridAuth 2.0 handle PHP Session only) and can be accessed directly by
	 * Hybrid_Auth::storage()->get($key) to retrieves the data for the given key, or calling
	 * Hybrid_Auth::storage()->set($key, $value) to store the key => $value set.
	 *
	 * @return Hybrid_Storage
	 */
	public static function storage() {
		return Hybrid_Auth::$store;
	}

	/**
	 * Get hybridauth session data
	 * @return string|null
	 */
	function getSessionData() {
		return Hybrid_Auth::storage()->getSessionData();
	}

	/**
	 * Restore hybridauth session data
	 *
	 * @param string $sessiondata Serialized session data
	 * @retun void
	 */
	function restoreSessionData($sessiondata = null) {
		Hybrid_Auth::storage()->restoreSessionData($sessiondata);
	}

	/**
	 * Try to authenticate the user with a given provider.
	 *
	 * If the user is already connected we just return and instance of provider adapter,
	 * ELSE, try to authenticate and authorize the user with the provider.
	 *
	 * $params is generally an array with required info in order for this provider and HybridAuth to work,
	 *  like :
	 *          hauth_return_to: URL to call back after authentication is done
	 *        openid_identifier: The OpenID identity provider identifier
	 *           google_service: can be "Users" for Google user accounts service or "Apps" for Google hosted Apps
	 *
	 * @param string $providerId ID of the provider
	 * @param array  $params      Params
	 * @return
	 */
	public static function authenticate($providerId, $params = null) {
		Hybrid_Logger::info("Enter Hybrid_Auth::authenticate( $providerId )");

		if (!Hybrid_Auth::storage()->get("hauth_session.$providerId.is_logged_in")) {
			// if user not connected to $providerId then try setup a new adapter and start the login process for this provider
			Hybrid_Logger::info("Hybrid_Auth::authenticate( $providerId ), User not connected to the provider. Try to authenticate..");
			$provider_adapter = Hybrid_Auth::setup($providerId, $params);
			$provider_adapter->login();
		} else {
			// else, then return the adapter instance for the given provider
			Hybrid_Logger::info("Hybrid_Auth::authenticate( $providerId ), User is already connected to this provider. Return the adapter instance.");
			return Hybrid_Auth::getAdapter($providerId);
		}
	}

	/**
	 * Return the adapter instance for an authenticated provider
	 *
	 * @param string $providerId ID of the provider
	 * @return Hybrid_Provider_Adapter
	 */
	public static function getAdapter($providerId = null) {
		Hybrid_Logger::info("Enter Hybrid_Auth::getAdapter( $providerId )");
		return Hybrid_Auth::setup($providerId);
	}

	/**
	 * Setup an adapter for a given provider
	 *
	 * @param string $providerId ID of the provider
	 * @param array  $params     Adapter params
	 * @return Hybrid_Provider_Adapter
	 */
	public static function setup($providerId, $params = null) {
		Hybrid_Logger::debug("Enter Hybrid_Auth::setup( $providerId )", $params);

		if (!$params) {
			$params = Hybrid_Auth::storage()->get("hauth_session.$providerId.id_provider_params");

			Hybrid_Logger::debug("Hybrid_Auth::setup( $providerId ), no params given. Trying to get the stored for this provider.", $params);
		}

		if (!$params) {
			$params = array();
			Hybrid_Logger::info("Hybrid_Auth::setup( $providerId ), no stored params found for this provider. Initialize a new one for new session");
		}

		if (is_array($params) && !isset($params["hauth_return_to"])) {
			$params["hauth_return_to"] = Hybrid_Auth::getCurrentUrl();
			Hybrid_Logger::debug("Hybrid_Auth::setup( $providerId ). HybridAuth Callback URL set to: ", $params["hauth_return_to"]);
		}

		# instantiate a new IDProvider Adapter
		$provider = new Hybrid_Provider_Adapter();
		$provider->factory($providerId, $params);
		return $provider;
	}

	/**
	 * Check if the current user is connected to a given provider
	 *
	 * @param string $providerId ID of the provider
	 * @return bool
	 */
	public static function isConnectedWith($providerId) {
		return (bool) Hybrid_Auth::storage()->get("hauth_session.{$providerId}.is_logged_in");
	}

	/**
	 * Return array listing all authenticated providers
	 * @return array
	 */
	public static function getConnectedProviders() {
		$idps = array();

		foreach (Hybrid_Auth::$config["providers"] as $idpid => $params) {
			if (Hybrid_Auth::isConnectedWith($idpid)) {
				$idps[] = $idpid;
			}
		}

		return $idps;
	}

	/**
	 * Return array listing all enabled providers as well as a flag if you are connected
	 *
	 * <code>
	 * array(
	 *   'Facebook' => array(
	 *     'connected' => true
	 *   )
	 * )
	 * </code>
	 * @return array
	 */
	public static function getProviders() {
		$idps = array();

		foreach (Hybrid_Auth::$config["providers"] as $idpid => $params) {
			if ($params['enabled']) {
				$idps[$idpid] = array('connected' => false);

				if (Hybrid_Auth::isConnectedWith($idpid)) {
					$idps[$idpid]['connected'] = true;
				}
			}
		}

		return $idps;
	}

	/**
	 * A generic function to logout all connected provider at once
	 * @return void
	 */
	public static function logoutAllProviders() {
		$idps = Hybrid_Auth::getConnectedProviders();

		foreach ($idps as $idp) {
			$adapter = Hybrid_Auth::getAdapter($idp);
			$adapter->logout();
		}
	}

	/**
	 * Utility function, redirect to a given URL with php header or using javascript location.href
	 *
	 * @param string $url  URL to redirect to
	 * @param string $mode PHP|JS
	 */
	public static function redirect($url, $mode = "PHP") {
		if(!$mode){
			$mode = 'PHP';
		}
		Hybrid_Logger::info("Enter Hybrid_Auth::redirect( $url, $mode )");

		// Ensure session is saved before sending response, see https://github.com/symfony/symfony/pull/12341
		if ((PHP_VERSION_ID >= 50400 && PHP_SESSION_ACTIVE === session_status()) || (PHP_VERSION_ID < 50400 && isset($_SESSION) && session_id())) {
			session_write_close();
		}

		if ($mode == "PHP") {
			header("Location: $url");
		} elseif ($mode == "JS") {
			echo '<html>';
			echo '<head>';
			echo '<script type="text/javascript">';
			echo 'function redirect(){ window.top.location.href="' . $url . '"; }';
			echo '</script>';
			echo '</head>';
			echo '<body onload="redirect()">';
			echo 'Redirecting, please wait...';
			echo '</body>';
			echo '</html>';
		}

		die();
	}

	/**
	 * Utility function, return the current url
	 *
	 * @param bool $request_uri true to get $_SERVER['REQUEST_URI'], false for $_SERVER['PHP_SELF']
	 * @return string
	 */
	public static function getCurrentUrl($request_uri = true) {
		if (php_sapi_name() == 'cli') {
			return '';
		}

		$protocol = 'http://';

		if ((isset($_SERVER['HTTPS']) && ( $_SERVER['HTTPS'] == 'on' || $_SERVER['HTTPS'] == 1 ))
				|| (isset($_SERVER['HTTP_X_FORWARDED_PROTO']) && $_SERVER['HTTP_X_FORWARDED_PROTO'] == 'https'))
		{
			$protocol = 'https://';
		}

		$url = $protocol . $_SERVER['HTTP_HOST'];

		if ($request_uri) {
			$url .= $_SERVER['REQUEST_URI'];
		} else {
			$url .= $_SERVER['PHP_SELF'];
		}

		// return current url
		return $url;
	}

}

여기에 코드를 입력하거나 붙여 넣습니다.

kakao.php – 아래코드

//https://github.com/jinseokoh/additional-providers
class Hybrid_Providers_Kakao extends Hybrid_Provider_Model_OAuth2
{
    /**
    * initialization
    */
    function initialize()
    {
        parent::initialize();

        // Provider API end-points
        $this->api->api_base_url  = "https://kapi.kakao.com/v2/";
        $this->api->authorize_url = "https://kauth.kakao.com/oauth/authorize";
        $this->api->token_url     = "https://kauth.kakao.com/oauth/token";

		// redirect uri mismatches when authenticating with Kakao.
		if (isset($this->config['redirect_uri']) && !empty($this->config['redirect_uri'])) {
			$this->api->redirect_uri = $this->config['redirect_uri'];
		}
    }

    /**
    * finish login step
    */
    function loginFinish()
    {
        $error = (array_key_exists('error', $_REQUEST)) ? $_REQUEST['error'] : "";
        // check for errors
        if ( $error ){
            throw new Exception( "Authentication failed! {$this->providerId} returned an error: $error", 5 );
        }
        // try to authenicate user
        $code = (array_key_exists('code', $_REQUEST)) ? $_REQUEST['code'] : "";
        try{
            $this->authenticate( $code );
        }
        catch( Exception $e ){
            throw new Exception( "User profile request failed! {$this->providerId} returned an error: $e", 6 );
        }
        // check if authenticated
        if ( ! $this->api->access_token ){
            throw new Exception( "Authentication failed! {$this->providerId} returned an invalid access token.", 5 );
        }
        // store tokens
        $this->token("access_token",  $this->api->access_token);
        $this->token("refresh_token", $this->api->refresh_token);
        $this->token("expires_in",    $this->api->access_token_expires_in);
        $this->token("expires_at",    $this->api->access_token_expires_at);
        // set user connected locally
        $this->setUserConnected();
    }

    /**
    * load the user profile
    */
    function getUserProfile()
    {
        //$params = array('property_keys'=>'kaccount_email');	// v1 parameter
        $params = array('property_keys'=>array('kakao_account.email'));		// v2 parameter

        $this->api->decode_json = false;
        $this->api->curl_header = array( 'Authorization: Bearer ' . $this->api->access_token );

        $data = $this->api->api("user/me", "POST", $params);

        if ( ! isset( $data->id ) ) {
            throw new Exception("User profile request failed! {$this->providerId} returned an invalid response.", 6);
        }
        # store the user profile.
        $this->user->profile->identifier  = @ $data->id;
        $this->user->profile->displayName = @ $data->properties->nickname;
        $this->user->profile->photoURL    = @ $data->properties->thumbnail_image;
        //$email = @ $data->properties->kaccount_email;	// v1 version
        
        $email = @ $data->kakao_account->email;   // v2 version

        if( $email ){
            $this->user->profile->email = $email;
        }

        $this->user->profile->sid         = get_social_convert_id( $this->user->profile->identifier, $this->providerId );

        return $this->user->profile;
    }

    private function authenticate($code)
    {
        $params = array(
            "grant_type"    => "authorization_code",
            "client_id"     => $this->api->client_id,
            "redirect_uri"  => $this->api->redirect_uri,
            "code"          => $code
        );

        if( $this->api->client_secret && ($this->api->client_secret !== $this->api->client_id) ){
            $params['client_secret'] = $this->api->client_secret;
        }

        $response = $this->request($this->api->token_url, $params, $this->api->curl_authenticate_method);
        $response = $this->parseRequestResult($response);
        if ( ! $response || ! isset($response->access_token) ) {
            throw new Exception("The Authorization Service has return: " . $response->error);
        }
        if ( isset($response->access_token) )  $this->api->access_token            = $response->access_token;
        if ( isset($response->refresh_token) ) $this->api->refresh_token           = $response->refresh_token;
        if ( isset($response->expires_in) )    $this->api->access_token_expires_in = $response->expires_in;

        // calculate when the access token expire
        if ( isset($response->expires_in) ) {
            $this->api->access_token_expires_at = time() + $response->expires_in;
        }

        return $response;
    }

    private function request($url, $params=false, $type="GET")
    {
        if(Class_exists('Hybrid_Logger')){
            Hybrid_Logger::info("Enter OAuth2Client::request( $url )");
            Hybrid_Logger::debug("OAuth2Client::request(). dump request params: ", serialize( $params ));
        }
        $this->http_info = array();
        $ch = curl_init();

        curl_setopt($ch, CURLOPT_URL           , $url);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
        curl_setopt($ch, CURLOPT_TIMEOUT       , $this->api->curl_time_out);
        curl_setopt($ch, CURLOPT_USERAGENT     , $this->api->curl_useragent);
        curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, $this->api->curl_connect_time_out);
        curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, $this->api->curl_ssl_verifypeer);
        curl_setopt($ch, CURLOPT_HTTPHEADER    , $this->api->curl_header);

        if ( $this->api->curl_proxy ) {
            curl_setopt( $ch, CURLOPT_PROXY, $this->curl_proxy);
        }
        if ( $type == "POST" ) {
            curl_setopt($ch, CURLOPT_POST, 1);
            if ($params) curl_setopt( $ch, CURLOPT_POSTFIELDS, http_build_query($params) );
        }

        $response = curl_exec($ch);
        if(Class_exists('Hybrid_Logger')){
            Hybrid_Logger::debug( "OAuth2Client::request(). dump request info: ", serialize(curl_getinfo($ch)) );
            Hybrid_Logger::debug( "OAuth2Client::request(). dump request result: ", serialize($response ));
        }
        $this->http_code = curl_getinfo($ch, CURLINFO_HTTP_CODE);
        $this->http_info = array_merge($this->http_info, curl_getinfo($ch));
        curl_close ($ch);

        return $response;
    }

    private function parseRequestResult($result)
    {
        if ( json_decode($result) ) return json_decode($result);
        parse_str( $result, $ouput );
        $result = new StdClass();
        foreach( $ouput as $k => $v )
            $result->$k = $v;

        return $result;
    }
}

웹에서는 정상적으로 한국어로 뜨는데
window프로그램 웹뷰창에서는 영어로 뜹니다.
파라미터 lang=ko로 설정값을 https://accounts.kakao.com/login에 보낼려면 따로 설정하는 값이 있는지
궁금합니다.

2
코드내용

3
카카오에 보내는 array 값

언어표기는 기본적으로 브라우저의 언어 설정에 따릅니다.
window프로그램 웹뷰의 언어 설정을 한국어로 하시거나

Kakao Account”; 주소 호출 할때, lang=ko 파라메터 사용하시면 설정에 상관없이 한국어로 표시됩니다.

좋아요 1