L'adaptation dynamique du widget contenu et la mise en page à la taille de l'utilisateur défini par l'intermédiaire de la redimensionner. Android

Android design pattern guide dit widget contenu et de la mise en page peut être réglé de façon dynamique à la taille de l'utilisateur défini par le redimensionnement d'images ici: Guide de conception pour les widgets

Exemple fourni dans le guide de conception:

Mais je ne vois rien dans les docs de la façon d'accomplir ceci. Comment faire pour changer la mise en page comme par opération de redimensionnement? Toutes les idées concernant l'approche sera appréciée.

Toutes les entrées de n'importe qui?
Il semble que c'est un Jellybean+ fonctionnalité, en raison de la AppWidgetProvider#onAppWidgetOptionsChanged() méthode. Une exemple j'ai trouvé la mettre en œuvre.
Est-il possible de connaître les dimensions de la fenêtre, de sorte que nous pouvons offrir une vue appropriée? Jellybean+ est aussi très bien.
Je vous remercie de votre itinéraire. Je suis en mesure de procéder comme je l'ai écrit dans la réponse ci-dessous pour JB appareils. S'il vous plaît écrire une réponse afin que je puisse la récompense.
Vous pourriez attendre jusqu'à ce que le bounty expire et répondre à votre propre question. Je me suis contenté de vous lier à un exemple 🙂

InformationsquelleAutor Gogu | 2013-01-11

android android-widget

Grâce à Un--C , c'est possible pour Jellybean et dispositifs ci-dessus et est simple à mettre en œuvre.
Ci-dessous l'exemple de code utilisant onAppWidgetOptionsChanged méthode

@TargetApi(Build.VERSION_CODES.JELLY_BEAN)
@Override
public void onAppWidgetOptionsChanged(Context context,
        AppWidgetManager appWidgetManager, int appWidgetId, Bundle newOptions) {

    Log.d(DEBUG_TAG, "Changed dimensions");

    //See the dimensions and
    Bundle options = appWidgetManager.getAppWidgetOptions(appWidgetId);

    //Get min width and height.
    int minWidth = options.getInt(AppWidgetManager.OPTION_APPWIDGET_MIN_WIDTH);
    int minHeight = options
            .getInt(AppWidgetManager.OPTION_APPWIDGET_MIN_HEIGHT);

            //Obtain appropriate widget and update it.
    appWidgetManager.updateAppWidget(appWidgetId,
            getRemoteViews(context, minWidth, minHeight));

    super.onAppWidgetOptionsChanged(context, appWidgetManager, appWidgetId,
            newOptions);
}

/**
 * Determine appropriate view based on width provided.
 * 
 * @param minWidth
 * @param minHeight
 * @return
 */
private RemoteViews getRemoteViews(Context context, int minWidth,
        int minHeight) {
    //First find out rows and columns based on width provided.
    int rows = getCellsForSize(minHeight);
    int columns = getCellsForSize(minWidth);

    if (columns == 4) {
        //Get 4 column widget remote view and return
    } else {
                    //Get appropriate remote view.
        return new RemoteViews(context.getPackageName(),
                R.layout.quick_add_widget_3_1);
    }
}

/**
 * Returns number of cells needed for given size of the widget.
 * 
 * @param size Widget size in dp.
 * @return Size in number of cells.
 */
 private static int getCellsForSize(int size) {
  int n = 2;
  while (70 * n - 30 < size) {
    ++n;
  }
  return n - 1;
 }

Tout d'abord, Vous ne devriez pas vous limiter à 4 cellules seulement. Utiliser une boucle comme ceci: pastebin.com/reexPt1m . Deuxièmement, vous oubliez de acount densité de l'écran. Troisièmement, il n'y a aucune garantie, que widget de taille 264dp va prendre jusqu'à 4 cellules. L'un de mes appareils Sony s'adapte 264dp en 3 cellules. Vous devez travailler avec la largeur de la présentation en dp et pas les cellules.
Mise à jour du code pour l'obtention de cellules. Je vous remercie. Vrai doit pas se limiter à 4 cellules seulement. Alors qu'il n'y a aucune garantie qu'il va prendre jusqu'à 4 cellules, ce sera une bonne estimation de la base de votre mise en page sur.
Bundle options = appWidgetManager.getAppWidgetOptions(appWidgetId); est la même que celle renvoyée Bundle newOptions
Une meilleure mise en œuvre de getCellsForSize() : return (int)(Math.ceil(taille + 30d)/70d);
Pourquoi après la modification de dispositions public void onUpdate(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) { //some click events } n'est pas appelé plus?
avez-vous trouvé la solution?
Je poste ma solution en réponse à ce post.

InformationsquelleAutor Gogu

@Choletski
@azendh

Après la modification de certaines dispositions sur les événements ne sont pas appelés plus

J'ai résolu ce problème en créant la fonction que setOnClickPendingIntent
sur afficher, puis le retourner.

Par exemple, le code est comme

private RemoteViews getConfiguredView (RemoteViews remoteViews, Context context){

    Intent refreshIntent = new Intent(context, EarningsWidget.class);
    refreshIntent.setAction(REFRESH_ACTION);
    PendingIntent toastPendingIntent = PendingIntent.getBroadcast(context, 3, refreshIntent, PendingIntent.FLAG_UPDATE_CURRENT);
    remoteViews.setOnClickPendingIntent(R.id.refreshButton, toastPendingIntent);
    return remoteViews;
}

Et que la fonction est appelée lorsque vous ne "appropriés, en vue à distance."

return getConfiguredView(new RemoteViews(context.getPackageName(), R.layout.activity_widget), context);

InformationsquelleAutor Jack the Ripper

Basé sur Gogu réponse et selon cette réponse sur la façon d'obtenir la taille de widget, je me suis créé ce WidgetClass dans Kotlin:

class WidgetClass: AppWidgetProvider() {
override fun onUpdate(context: Context?, appWidgetManager: AppWidgetManager?, appWidgetIds: IntArray?) {
for (id in appWidgetIds!!) {
//get widget options for later get widget dimensions
val options = appWidgetManager?.getAppWidgetOptions(id)
//get widget view based on widget size
val view = getView(context, options)
//update widget
appWidgetManager!!.updateAppWidget(id, view)
}
}
//listen for widget changes
override fun onAppWidgetOptionsChanged(context: Context?, appWidgetManager: AppWidgetManager?,
appWidgetId: Int, newOptions: Bundle?) {
//update widget view based on new options
appWidgetManager?.updateAppWidget(appWidgetId, getView(context, newOptions))
super.onAppWidgetOptionsChanged(context, appWidgetManager, appWidgetId, newOptions)
}
private fun getView(context: Context?, options: Bundle?): RemoteViews {
val minWidth: Int
val minHeight: Int
if (context!!.resources.configuration.orientation == ActivityInfo.SCREEN_ORIENTATION_PORTRAIT
|| context.resources.configuration.orientation == ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT) {
minWidth = options?.getInt(AppWidgetManager.OPTION_APPWIDGET_MIN_WIDTH) ?: 0
minHeight = options?.getInt(AppWidgetManager.OPTION_APPWIDGET_MAX_HEIGHT) ?: 0
} else {
minWidth = options?.getInt(AppWidgetManager.OPTION_APPWIDGET_MAX_WIDTH) ?: 0
minHeight = options?.getInt(AppWidgetManager.OPTION_APPWIDGET_MIN_HEIGHT) ?: 0
}
//get widget view accordin widget size
return if (minWidth >= 240)
RemoteViews(context.packageName, R.layout.widget_large)
else
RemoteViews(context.packageName, R.layout.widget_small)
}
}

InformationsquelleAutor Osvel Alvarez Jacomino

Vous devez vous connecter pour publier un commentaire.