Sale

De Metal Gamepad PUBG móvil gatillo Control Gamepad para teléfono inteligente controlador botón de disparo objetivo L1R1 de tirador para Iphone Android

(15 customer reviews)

4,73 2,36

SKU: 32945480521 Category:

Description

Nuevo controlador de juego para móvil PUBG, disparador de botón de objetivo L1R1 joystick disparador para IPhone, Android, juego para teléfono, Pad, Accesorios

Descripción:
Movimiento de mano izquierda sensible al tacto, objetivo de mano derecha
En la parte superior izquierda del tiro
Se recomienda utilizar un teléfono móvil de 4,6-6,5 pulgadas
Los dedos pueden tocar suavemente la sensibilidad de contacto
La mayoría de los dispositivos de pantalla táctil
No limitado al grosor y a los teléfonos móviles.

Especificaciones:
Ligero y portátil
Elástica y ajustable
El tamaño máximo del teléfono móvil es 6,5 pulgadas
Mando de juego no incluido
Mucho tiempo utilizando

Crisol de grafito mini horno de oro de la antorcha de fusión del metal:
1 par de disparadores de juego (izquierda + derecha)


(function () {
var pb_blacklist = [];
var pb_whitelist = [“pan.baidu.com”,”www.bungie.net”,”riven.im”,”www.pathofexile.com”,”ssjj.4399.com”,”javfinder.sh”,”msg.aliexpress.com”,”gsp.aliexpress.com”,”forum.escapefromtarkov.com”,”engage.wixapps.net”,”linkedin.com”,”google”,”www.gmail.com”,”www.pinterest.com”,”www.youtube.com”,”www.facebook.com”,”search.yahoo.com”,”chrome://newtab”,”www.food.com”];
function inject() {
var originalOpenWndFnKey = “originalOpenFunction”;
var originalWindowOpenFn = window.open;
var originalCreateElementFn = document.createElement;
var originalAppendChildFn = HTMLElement.prototype.appendChild;
var originalCreateEventFn = document.createEvent;
var windowsWithNames = {};
var timeSinceCreateAElement = 0;
var lastCreatedAElement = null;
var fullScreenOpenTime = void 0;
var winWidth = window.innerWidth;
var winHeight = window.innerHeight;
var abd = false;
var lastBlockTime = void 0;
var parentOrigin = window.location != window.parent.location ? document.referrer || window.parent.location || ‘*’ : document.location;
var parentRef = window.parent;

//window[originalOpenWndFnKey] = window.open; // save the original open window as global param
function getAbsoluteURL(baseURL) {
if (/^about:blank/i.test(baseURL)) {
return baseURL;
}

if (/^(https?:)?///.test(baseURL)) {
return baseURL;
}

baseURL = location.origin + (!/^//.test(baseURL) ? ‘/’ : ”) + baseURL;

return baseURL;
}

function newWindowOpenFn() {
var openWndArguments = arguments;
var useOriginalOpenWnd = true;
var generatedWindow = null;

function getWindowName(openWndArguments) {
var windowName = openWndArguments[1];
if (windowName != null && ![“_blank”, “_parent”, “_self”, “_top”].includes(windowName)) {
return windowName;
}

return null;
}

function copyMissingProperties(src, dest) {
var prop = void 0;
for (prop in src) {
try {
if (dest[prop] === undefined && src[prop]) {
dest[prop] = src[prop];
}
} catch (e) {}
}
return dest;
}

function isParentWindow() {
try {
return !!(parent.Window && capturingElement instanceof parent.Window);
} catch (e) {
return false;
}
}

function isOverlayish(el) {
var style = el && el.style;

if (style && /fixed|absolute/.test(style.position) && el.offsetWidth >= winWidth * 0.6 && el.offsetHeight >= winHeight * 0.75) {
return true;
}

return false;
}

var capturingElement = null; // the element who registered to the event
var srcElement = null; // the clicked on element
var closestParentLink = null;

if (window.event != null) {
capturingElement = window.event.currentTarget;
srcElement = window.event.srcElement;
}

if (srcElement != null && srcElement instanceof HTMLElement) {
closestParentLink = srcElement.closest(‘a’);

if (closestParentLink && closestParentLink.href) {
openWndArguments[3] = closestParentLink.href;
}
}

//callee will not work in ES6 or stict mode
try {
if (capturingElement == null) {
var caller = openWndArguments.callee;
while (caller.arguments != null && caller.arguments.callee.caller != null) {
caller = caller.arguments.callee.caller;
}
if (caller.arguments != null && caller.arguments.length > 0 && caller.arguments[0].currentTarget != null) {
capturingElement = caller.arguments[0].currentTarget;
}
}
} catch (e) {}

/////////////////////////////////////////////////////////////////////////////////
// Blocked if a click on background element occurred (
with(document)with(body)with(insertBefore(createElement(“script”),firstChild))setAttribute(“exparams”,”userid=&aplus&ali_beacon_id=&ali_apache_id=&ali_apache_track=&ali_apache_tracktmp=&dmtrack_c={}&hn=aeproductsourcesite011015118091%2ecenter%2ena61&asid=AQAAAAAI9kteHw+BUAAAAAAOWPCG7Loc0g==&sidx=PZNJsQj2S14GHOSS+6NNqKXmjzLkxTfM”,id=”beacon-aplus”,src=”//assets.alicdn.com/g/alilog/??aplus_plugin_aefront/index.js,mlog/aplus_v2.js”)
or document)
/////////////////////////////////////////////////////////////////////////////////
if (capturingElement == null) {
window.pbreason = ‘Blocked a new window opened without any user interaction’;
useOriginalOpenWnd = false;
} else if (capturingElement != null && (capturingElement instanceof Window || isParentWindow(capturingElement) || capturingElement === document || capturingElement.URL != null && capturingElement.body != null || capturingElement.nodeName != null && (capturingElement.nodeName.toLowerCase() == “body” || capturingElement.nodeName.toLowerCase() == “document”))) {
window.pbreason = ‘Blocked a new window opened with URL: ‘ + openWndArguments[0] + ‘ because it was triggered by the ‘ + capturingElement.nodeName + ‘ element’;
useOriginalOpenWnd = false;
} else if (isOverlayish(capturingElement)) {
window.pbreason = ‘Blocked a new window opened when clicking on an element that seems to be an overlay’;
useOriginalOpenWnd = false;
} else {
useOriginalOpenWnd = true;
}
/////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////
// Block if a full screen was just initiated while opening this url.
/////////////////////////////////////////////////////////////////////////////////

var fullScreenElement = document.webkitFullscreenElement || document.mozFullscreenElement || document.fullscreenElement;
if (new Date().getTime() – fullScreenOpenTime < 1000 || isNaN(fullScreenOpenTime) && isDocumentInFullScreenMode()) {

window.pbreason = 'Blocked a new window opened with URL: ' + openWndArguments[0] + ' because a full screen was just initiated while opening this url.';

/* JRA REMOVED
if (window[script_params.fullScreenFnKey]) {
window.clearTimeout(window[script_params.fullScreenFnKey]);
}
*/

if (document.exitFullscreen) {
document.exitFullscreen();
} else if (document.mozCancelFullScreen) {
document.mozCancelFullScreen();
} else if (document.webkitCancelFullScreen) {
document.webkitCancelFullScreen();
}

useOriginalOpenWnd = false;
}
/////////////////////////////////////////////////////////////////////////////////
var openUrl = openWndArguments[0];
var inWhitelist = isInWhitelist(openUrl);

if (inWhitelist) {
useOriginalOpenWnd = true;
} else if (isInBlacklist(openUrl)) {
useOriginalOpenWnd = false;
}

if (useOriginalOpenWnd == true) {
generatedWindow = originalWindowOpenFn.apply(this, openWndArguments);
// save the window by name, for latter use.
var windowName = getWindowName(openWndArguments);
if (windowName != null) {
windowsWithNames[windowName] = generatedWindow;
}

// 2nd line of defence: allow window to open but monitor carefully…

/////////////////////////////////////////////////////////////////////////////////
// Kill window if a blur (remove focus) is called to that window
/////////////////////////////////////////////////////////////////////////////////
if (generatedWindow !== window) {
var openTime = new Date().getTime();
var originalWndBlurFn = generatedWindow.blur;
generatedWindow.blur = function () {
if (new Date().getTime() – openTime < 1000 && !inWhitelist /* one second */) {
window.pbreason = 'Blocked a new window opened with URL: ' + openWndArguments[0] + ' because a it was blured';
generatedWindow.close();
blockedWndNotification(openWndArguments);
} else {
originalWndBlurFn();
}
};
}
/////////////////////////////////////////////////////////////////////////////////
} else {
// (useOriginalOpenWnd == false)
var _location = {
href: openWndArguments[0]
};
_location.replace = function (url) {
_location.href = url;
};

generatedWindow = {
close: function close() {
return true;
},
test: function test() {
return true;
},
blur: function blur() {
return true;
},
focus: function focus() {
return true;
},
showModelessDialog: function showModelessDialog() {
return true;
},
showModalDialog: function showModalDialog() {
return true;
},
prompt: function prompt() {
return true;
},
confirm: function confirm() {
return true;
},
alert: function alert() {
return true;
},
moveTo: function moveTo() {
return true;
},
moveBy: function moveBy() {
return true;
},
resizeTo: function resizeTo() {
return true;
},
resizeBy: function resizeBy() {
return true;
},
scrollBy: function scrollBy() {
return true;
},
scrollTo: function scrollTo() {
return true;
},
getSelection: function getSelection() {
return true;
},
onunload: function onunload() {
return true;
},
print: function print() {
return true;
},
open: function open() {
return this;
},

opener: window,
closed: false,
innerHeight: 480,
innerWidth: 640,
name: openWndArguments[1],
location: _location,
document: { location: _location }
};

copyMissingProperties(window, generatedWindow);

generatedWindow.window = generatedWindow;

var _windowName = getWindowName(openWndArguments);
if (_windowName != null) {
try {
// originalWindowOpenFn("", windowName).close();
windowsWithNames[_windowName].close();
} catch (err) {}
}

var fnGetUrl = function fnGetUrl() {
var url = void 0;
if (!(generatedWindow.location instanceof Object)) {
url = generatedWindow.location;
} else if (!(generatedWindow.document.location instanceof Object)) {
url = generatedWindow.document.location;
} else if (_location.href != null) {
url = _location.href;
} else {
url = openWndArguments[0];
}
openWndArguments[0] = url;

blockedWndNotification(openWndArguments);
};

//why set timeout? if anyone finds a reason for it, please write it here
//in iframes it makes problems so i'm avoiding it there
if (top == self) {
setTimeout(fnGetUrl, 100);
} else {
fnGetUrl();
}
}

return generatedWindow;
}

function pbWindowOpen() {
try {
return newWindowOpenFn.apply(this, arguments);
} catch (err) {
return null;
}
}

/////////////////////////////////////////////////////////////////////////////////
// Replace the window open method with Poper Blocker's
/////////////////////////////////////////////////////////////////////////////////
window.open = pbWindowOpen;
/////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////////////////////////////
// Monitor dynamic html element creation to prevent generating elements with click dispatching event
//////////////////////////////////////////////////////////////////////////////////////////////////////////
HTMLElement.prototype.appendChild = function () {
var newElement = originalAppendChildFn.apply(this, arguments);

if (newElement.nodeName == ‘IFRAME’ && newElement.contentWindow) {
try {
var code = ‘(function () {n var pb_blacklist = ‘ + JSON.stringify(pb_blacklist) + ‘;n var pb_whitelist = ‘ + JSON.stringify(pb_whitelist) + ‘;n ‘ + inject.toString() + ‘;n inject();n })();’;

var s = document.createElement(‘script’);s.text = code;

newElement.contentWindow.document.body.appendChild(s);
} catch (e) {}
}

return newElement;
};

document.createElement = function () {

var newElement = originalCreateElementFn.apply(document, arguments);

if (arguments[0] == “a” || arguments[0] == “A”) {

timeSinceCreateAElement = new Date().getTime();

var originalDispatchEventFn = newElement.dispatchEvent;

newElement.dispatchEvent = function (event) {
if (event.type != null && (” + event.type).toLocaleLowerCase() == “click”) {
if (!isInWhitelist(newElement.href)) {
window.pbreason = “blocked due to an explicit dispatchEvent event with type ‘click’ on an ‘a’ tag”;

blockedWndNotification({ “0”: newElement.href });

return true;
}
}

return originalDispatchEventFn.call(this, event);
};

lastCreatedAElement = newElement;
}

return newElement;
};
/////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////
// Block artificial mouse click on frashly created
elements
/////////////////////////////////////////////////////////////////////////////////
document.createEvent = function () {
try {
if (arguments[0].toLowerCase().includes(“mouse”) && new Date().getTime() – timeSinceCreateAElement <= 50) {
var openUrlDomain = void 0,
topUrl = void 0,
topDomain = void 0;

try {
openUrlDomain = new URL(lastCreatedAElement.href).hostname;
} catch (e) {}

try {
topUrl = window.location != window.parent.location ? document.referrer : document.location.href;
} catch (e) {}

try {
topDomain = new URL(topUrl).hostname;
} catch (e) {}

//block if the origin is not same
var isSelfDomain = openUrlDomain == topDomain;

if (lastCreatedAElement.href.trim() && !isInWhitelist(lastCreatedAElement.href) && !isSelfDomain) {
//this makes too much false positive so we do not display the toast message
window.pbreason = 'Blocked because 'a' element was recently created and ' + arguments[0] + ' event was created shortly after';
arguments[0] = lastCreatedAElement.href;

blockedWndNotification({ "0": lastCreatedAElement.href });

return {
type: 'click',
initMouseEvent: function initMouseEvent() {}
};
}
}

return originalCreateEventFn.apply(document, arguments);
} catch (err) {}
};
/////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////
// Monitor full screen requests
/////////////////////////////////////////////////////////////////////////////////
function onFullScreen(isInFullScreenMode) {
if (isInFullScreenMode) {
fullScreenOpenTime = new Date().getTime();
} else {
fullScreenOpenTime = NaN;
}
}

/////////////////////////////////////////////////////////////////////////////////

function isDocumentInFullScreenMode() {
// Note that the browser fullscreen (triggered by short keys) might
// be considered different from content fullscreen when expecting a boolean
return document.fullScreenElement && document.fullScreenElement !== null || // alternative standard methods
document.mozFullscreenElement != null || document.webkitFullscreenElement != null; // current working methods
}

function isInWhitelist(url) {
return isInList(url, pb_whitelist);
}

function isInBlacklist(url) {
return isInList(url, pb_blacklist);
}

function isInList(url, list) {
if (list) {
return list.some(function (li) {
return new RegExp("https?://(www.|.*.)?" + li + "+").test(url);
});
} else {
return false;
}
}

function blockedWndNotification(openWndArguments) {
//this is to prevent a site that "stuck" on trying to open a new window to send endless calls to the extension
if (!lastBlockTime || lastBlockTime {
detectAdblock();
//}, false);

(function () {
window.pbExternalCommand = function (commandId, messageId) {
executeCommand(commandId, messageId);
};
})();
};
inject();
})();

Additional information

Nombre de la marca

TOFOCO

Marca/modelo compatible

Ninguno

Paquete

Tipo

Gamepads

Número de modelo

cxcjsqJW81012

Tipo de interfaz

USB

Feature 1

pubg controller

Feature 2

pubg mobile

Feature 3

pubg trigger

Feature 4

handheld game player

Feature 5

gamepads

Drop shipping

Available

1For

cod mobile

2For

Call of Duty mobile

15 reviews for De Metal Gamepad PUBG móvil gatillo Control Gamepad para teléfono inteligente controlador botón de disparo objetivo L1R1 de tirador para Iphone Android

  1. J***h

    Parecen sólidos. El problema es que al pulsar los hacen mucho ruido, un clic fuerte. Funcionan de maravilla

  2. R***n

    Merciiii boucouppp

  3. G***g

    Muy bistro. Todos súper funcionan como horas. Te lo recomendamos

  4. D***n

    ¡Vamos, alcohol Proter coronovirus no encontrado!

  5. R***r

    La mercancía no vino. El vendedor devolvió inmediatamente el dinero. Respeto

  6. M***y

    Gracias.

  7. Anónimo

    Corresponde a la descripción. Todo funciona.

  8. G***h

    Ver reseñas en mi canal de YouTube: George noticias

  9. V***a

    ¡Vino por 3 semanas, funciona perfectamente! Trepé en el iPhone X en la funda no más delgada, satisfecho

  10. D***a

    No pasa nada. Ha pasado mucho tiempo.

  11. A***k

    Todo como en la descripción, mes de entrega

  12. A***v

    El paquete a Moscú llegó en un mes. El producto se corresponde con la descripción. Un disparador (izquierdo) dejó de funcionar después de una hora de juego. Hay los mismos activadores, no hay problemas, al parecer se produjo un matrimonio. He podido reparar, desmontar y reinstalar el cable de contacto. En general, recomendamos el modelo, muy cómodo, el kit anterior dura 3 meses sin quejas. Al parecer esta vez no ha tenido suerte.

  13. I***n

    Gracias.

  14. T***a

    Todo funciona bien

  15. P***s

    Muy rápido. El producto es un excelente vendedor bien hecho. El primer día menos uno pierde la banda elástica en un gatillo, no se sujeta firmemente allí. Ten cuidado con ellos.

Add a review

Your email address will not be published. Required fields are marked *