getSize() non pris en charge sur les anciennes versions OS Android, getWidth () et getHeight() obsolète

Alors, comment dois-je écrire du code pour tenir compte de cela? Je ne veux pas laisser les appels aux API obsolètes dans mon code, mais je ne veux pas perdre les utilisateurs avec (un peu) les appareils plus anciens. Est-il une sorte de paramètre de compatibilité, je peux le mettre en œuvre?

Rel. code

Display display = getWindowManager().getDefaultDisplay();
Point size = new Point();
display.getSize(size);
int screen_width = size.x;
int screen_height = size.y;

vs l'ancienne méthode:

int screen_width = getWindowManager().getDefaultDisplay().getWidth();
int screen_height = getWindowManager().getDefaultDisplay().getHeight();

OriginalL'auteur karl_ | 2012-05-03

3

Le meilleur (et le meilleur, je veux dire l'option qui fonctionne presque à chaque fois) option serait d'utiliser la réflexion. Découvrez le Android ~~Rétro-Compatibilité~~ Rétro-Compatibilité lignes directrices (mis à jour avec le nouvel emplacement de l'article sur la réflexion).

Tout tyczj réponse fonctionne parfaitement tant que le obsolète fonctions sont encore dans le SDK, dès qu'ils sont retirés, vous n'aurez aucun moyen de les utiliser ou de l'exécution de votre application sur un appareil plus ancien, si vous voulez continuer à construire contre le dernier SDK.

Réflexion résoudre ce problème efficacement de façon dynamique la détection de la fonction au moment de l'exécution, ce qui signifie que même si vous construisez contre ICS, tant que le minSdkVersion est correct, vous pouvez avoir votre application de fonctionner sur un appareil avec du pain d'épice, ou Froyo par exemple.

Je n'avais pas vu cette partie du développeur documents encore bonne réponse.
Il est assez obscure, si vous ne savez pas quoi chercher, je suis tombé sur ça totalement par hasard.
Alors, quelle est la réflexion. Je crois que le lien est mort.
Le lien developer.android.com/resources/articles/... n'est plus actif.
J'ai mis à jour le lien

OriginalL'auteur RivieraKid

j'ai deux fonctions, l'envoi du contexte et gettin la hauteur et la largeur en pixels.

public static int getWidth(Context mContext){
    int width=0;
    WindowManager wm = (WindowManager) mContext.getSystemService(Context.WINDOW_SERVICE);
    Display display = wm.getDefaultDisplay();
    if(Build.VERSION.SDK_INT>Build.VERSION_CODES.HONEYCOMB){                   
        Point size = new Point();
        display.getSize(size);
        width = size.x;
    }
    else{
        width = display.getWidth();  //deprecated
    }
    return width;
}

public static int getHeight(Context mContext){
    int height=0;
    WindowManager wm = (WindowManager) mContext.getSystemService(Context.WINDOW_SERVICE);
    Display display = wm.getDefaultDisplay();
    if(Build.VERSION.SDK_INT>Build.VERSION_CODES.HONEYCOMB){               
        Point size = new Point();
        display.getSize(size);
        height = size.y;
    }else{          
        height = display.getHeight();  //deprecated
    }
    return height;      
}

OriginalL'auteur Elenasys

3

vous pouvez faire quelque chose comme ceci
```
if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH){
           //do stuff pertaining to this version here
}else{
           //other versions
}
```
bienvenue dans le monde de la compatibilité.
Qui a fait le tour. Vous ne désordre des choses bien.
Malheureusement, cela ne fonctionne que pour aussi longtemps que les anciennes méthodes sont dans la version du SDK. @karl_, vous n'avez pas explicitement état exactement quel âge un appareil que vous voulez soutenir, mais l'utilisation de la réflexion comme dans ma réponse va vous permettre de soutenir toute version d'Android quel que soit le SDK que vous construisez contre.

OriginalL'auteur tyczj

Je pense genre de chose RivieraKid est penser, ce qui serait quelque chose comme ceci:

static Point getDisplaySize(Display d)
{
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB)
{
return getDisplaySizeGE11(d);
}
return getDisplaySizeLT11(d);
}
@TargetApi(Build.VERSION_CODES.HONEYCOMB_MR2)
static Point getDisplaySizeGE11(Display d)
{
Point p = new Point(0, 0);
d.getSize(p);
return p;
}
static Point getDisplaySizeLT11(Display d)
{
try
{
Method getWidth = Display.class.getMethod("getWidth", new Class[] {});
Method getHeight = Display.class.getMethod("getHeight", new Class[] {});
return new Point(((Integer) getWidth.invoke(d, (Object[]) null)).intValue(), ((Integer) getHeight.invoke(d, (Object[]) null)).intValue());
}
catch (NoSuchMethodException e2) //None of these exceptions should ever occur.
{
return new Point(-1, -1);
}
catch (IllegalArgumentException e2)
{
return new Point(-2, -2);
}
catch (IllegalAccessException e2)
{
return new Point(-3, -3);
}
catch (InvocationTargetException e2)
{
return new Point(-4, -4);
}
}

OriginalL'auteur Steve Waring

D'habitude, j'ai une super classe ie. BaseActivity avec une méthode générique pour arriver à un point de l'écran courant taille. Garde tout ce qui est beau et propre à l'activité réelle.

/**
* Return screen size as a point.
* @return
*/
@TargetApi(Build.VERSION_CODES.HONEYCOMB_MR2)
@SuppressWarnings("deprecation")
protected Point getSize() {
final Point point = new Point();
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB_MR2) {
getWindowManager().getDefaultDisplay().getSize(point);
}
else {
final Display display = getWindowManager().getDefaultDisplay();
point.x = display.getWidth();
point.y = display.getHeight();
}
return point;
}

OriginalL'auteur slott

Vous devez vous connecter pour publier un commentaire.