¿Hay alguna forma de desactivar la función de zoom en los campos de entrada en la vista web?

Question

Cuando un usuario hace clic en un campo de entrada o en un área de texto, la aplicación amplía. ¿Hay una manera simple de desactivarlo?

Actualmente tienen la etiqueta meta:

meta name="viewport" content="width=device-width; height=device-height; initial-scale=1.0; maximum-scale=1.0; user-scalable=no; target-densityDpi=device-dpi;" 

Todo se ve muy bien hasta que me miro en un dispositivo con Android 2.2 Específicamente HTC Evo 4G.

Answer 1

Me metí con este montón.

Tiene que tener diferentes soluciones para diferentes tamaños de pantalla y teléfonos, en el lado del servidor.

Esto funciona para el deseo de HTC por ejemplo:

<meta content='True' name='HandheldFriendly' /> 
<meta content='width=640px; initial-scale=0.50; maximum-scale=0.50;minimum-scale=0.50;' name='viewport' /> 
<meta name="viewport" content="width=640px" /> 

Se trata de un iPhone:

<meta name="viewport" content="width=640px,user-scalable=0" /> 

Answer 2

Tengo el mismo problema (en un HTC Incredible) y aún no hemos encontrado una buena solución. Pero, una cosa que noté es que si usa el sitio móvil de Google (http://google.com/m) no obtiene este comportamiento, estoy tratando de averiguar por qué es así.

He intentado todas las correcciones mencionadas en stackoverflow que pude encontrar, incluso en este hilo y nada de lo que he encontrado funciona hasta ahora.

Una maldita solución He encontrado que el trabajo es establecer la escala inicial en 150 (1.5X) y luego escalar su sitio web en consecuencia, entonces tampoco obtiene este comportamiento de acercamiento, tal vez porque quiere un nivel de zoom de 1.5X cuando haces clic en una entrada de texto y si ya estás en ese nivel de zoom, ¿no pasa nada? Pero, esto se siente súper hacky y probablemente no sea robusto en todos los teléfonos.

Answer 3

Así es como puedo resuelto que:

En todas mis páginas que tengo:

<link rel="stylesheet" media="screen and (-webkit-device-pixel-ratio:0.75)" href="css/ldpi.css" /> 
<link rel="stylesheet" media="screen and (-webkit-device-pixel-ratio:1)" href="css/mdpi.css" /> 
<link rel="stylesheet" media="screen and (-webkit-device-pixel-ratio:1.5)" href="css/hdpi.css" /> 
<meta name="viewport" content="target-densitydpi=device-dpi" /> 

En las páginas con campos de entrada, que tengo:

<link rel="stylesheet" media="screen" href="css/mdpi.css" /> 
<meta name="viewport" content="target-densitydpi=medium-dpi" /> 

Por lo tanto, Don no se beneficia de hdpi en los formularios, pero al menos no hace zoom en

Answer 4

Encontré la respuesta, al menos para yo. Funciona con HTC desire y Sansung 3 low res.

• Elimina las etiquetas meta de la vista del HTML.

• En java, aplique la solución que se puede encontrar here.

  this.appView.getSettings().setSupportZoom(true); //Modify this 
  this.appView.getSettings().setDefaultZoom(WebSettings.ZoomDensity.FAR);//Add this 
  

  recuerde probar si WebSettings.ZoomDensity.FAR está disponible para la versión SDK (7 y superior).

Answer 5

hay un campo int la webview.class mDefaultScale flotar el código fuente muestra que cuando se muestra la softkeyboard mActualScale va a cambiar. por lo que mDefaultScale es el problema. puedes aprenderlo desde el sitio grepcode.

private void displaySoftKeyboard(boolean isTextView) { 
    InputMethodManager imm = (InputMethodManager) 
    getContext().getSystemService(Context.INPUT_METHOD_SERVICE); 
     if (isTextView) { 
      if (mWebTextView == null) return; 
      imm.showSoftInput(mWebTextView, 0); 

      if (mActualScale < mDefaultScale) { 

       // bring it back to the default scale so that user can enter 

       // text. 
       mInZoomOverview = false; 
       mZoomCenterX = mLastTouchX; 
       mZoomCenterY = mLastTouchY; 
       // do not change text wrap scale so that there is no reflow 
       setNewZoomScale(mDefaultScale, false, false); 
       adjustTextView(false); 
      } 
     } 

     else { // used by plugins 
      imm.showSoftInput(this, 0); 
     } 

    } 

Answer 6

¿No es esto simplemente un problema de ajuste de tamaño de texto?

body{ 
    -webkit-text-size-adjust:none; 
} 

Answer 7

Sé que este hilo es historia antigua pero tenía el problema de escala con el teclado virtual y, finalmente, encontró la solución en este enlace:

http://rickluna.com/wp/2012/02/set-app-scaling-in-phonegap-android/

Añadir estas líneas a fuente de Java de la aplicación

appView.getSettings().setSupportZoom(false); 
appView.getSettings().setUseWideViewPort(false); 
WebSettings ws = appView.getSettings(); 
ws.setDefaultZoom(WebSettings.ZoomDensity.MEDIUM); 
appView.getSettings().setDefaultZoom(WebSettings.ZoomDensity.MEDIUM); 
appView.setInitialScale(0); 
ws.setSupportZoom(false); 
ws.setBuiltInZoomControls(false); 
ws.setUseWideViewPort(false); 

Cambié MEDIUM a FAR que mantiene la pantalla con la ampliación original de 1,0.

Esperemos que salva a otras personas algunas búsquedas

Answer 8

webView.getSettings().setDefaultZoom(WebSettings.ZoomDensity.MEDIUM); 

Este método está desfasada y en el nivel API 19.

esto funciona en las últimas versiones de Android 4.4.2.

webView.setInitialScale(0);//default,no zoom 
webView.getSettings().setSupportZoom(true); 
webView.getSettings().setBuiltInZoomControls(true); 
webView.getSettings().setLoadWithOverviewMode(false); 
webView.getSettings().setUseWideViewPort(false); 
webView.getSettings().setJavaScriptCanOpenWindowsAutomatically(true); 

Answer 9

acaba de establecer en el manifiesto:

android:windowSoftInputMode="adjustPan" 

Answer 10

Por último, he encontrado una solución para mi proyecto en el mundo real.

- MainActivity.java 

@Override 
public void onCreate(Bundle savedInstanceState) { 
    super.onCreate(savedInstanceState); 
    setContentView(R.layout.activity_main); 
    WebView mWebView = (WebView) findViewById(R.id.webview); 
    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.KITKAT) { 
     mWebView.setOnFocusChangeListener(new MyOnFocusChangeListener(getScale())); 
    } 
    Log.i(MainActivity.class.getSimpleName(), "getScale: " + getScale()); 
} 

/** 
* Calculate the scale that we need to use manually. 
* 
* @return the scale that we need 
*/ 
private float getScale() { 
    DisplayMetrics display = this.getResources().getDisplayMetrics(); 
    int width = display.widthPixels; 
    Float val = Float.valueOf(width)/Float.valueOf(Constants.PAGE_WIDTH); 
    return val.floatValue(); 
} 

- MyOnFocusChangeListener.java 

public class MyOnFocusChangeListener implements View.OnFocusChangeListener { 

    protected float mScale; 

    public MyOnFocusChangeListener(float scale) { 
     mScale = scale; 
    } 

    /** 
    * Implement this method because we want to apply scale when focus changed. 
    * @param v the View we want to apply scale when focus changed. 
    * @param hasFocus has a focus or not. 
    */ 
    public void onFocusChange(View v, boolean hasFocus) { 
     if (hasFocus) { 
      // We must try all cases because mDefaultScale will change on different versions of Android. 
      try { 
       Field defaultScale = WebView.class.getDeclaredField("mDefaultScale"); 
       defaultScale.setAccessible(true); 
       defaultScale.setFloat(v, mScale); 
      } catch (SecurityException e) { 
       e.printStackTrace(); 
      } catch (IllegalArgumentException e) { 
       e.printStackTrace(); 
      } catch (IllegalAccessException e) { 
       e.printStackTrace(); 
      } catch (NoSuchFieldException e) { 
       try { 
        Field zoomManager; 
        zoomManager = WebView.class.getDeclaredField("mZoomManager"); 
        zoomManager.setAccessible(true); 
        Object zoomValue = zoomManager.get(v); 
        Field defaultScale = zoomManager.getType().getDeclaredField("mDefaultScale"); 
        defaultScale.setAccessible(true); 
        defaultScale.setFloat(zoomValue, mScale); 
       } catch (SecurityException e1) { 
        e1.printStackTrace(); 
       } catch (IllegalArgumentException e1) { 
        e.printStackTrace(); 
       } catch (IllegalAccessException e1) { 
        e.printStackTrace(); 
       } catch (NoSuchFieldException e1) { 
        try { 
         Field mProviderField = WebView.class.getDeclaredField("mProvider"); 
         mProviderField.setAccessible(true); 
         Object webviewclassic = mProviderField.get(v); 
         Field zoomManager = webviewclassic.getClass().getDeclaredField("mZoomManager"); 
         zoomManager.setAccessible(true); 
         Object zoomValue = zoomManager.get(webviewclassic); 
         Field defaultScale = zoomManager.getType().getDeclaredField("mDefaultScale"); 
         defaultScale.setAccessible(true); 
         defaultScale.setFloat(zoomValue, mScale); 
        } catch (Exception e2) { 
         e2.printStackTrace(); 
        } 
       } 
      } 
     } 
    } 
}