Discussion :

[stelincat]

Bonjour à tous,

J'ai une activity avec des onglets, chaque onglet (deux) est représenté par un Fragment. sur un bouton refresh (dans la barre du haut) je fait appel à un WebService qui est lancé en Async depuis l'activity. Ce traitement Async me renvoie du Json, et dans l'activity au retour de l'Async, je met à jours la base de données avec ce flux Json.

J'aimerai maintenant que le visuel (les deux fragments ou voir que celui sélectionné) se affranchisse (rafraîchissement lancer de puis l'activity), mais je ne voit pas quoi lancer.

Par avance merci.

[andronull]

tu pourra poster ton code ?

[stelincat]

Voilà le code j'ai viré les commentaire et des bout de code pour alléger.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
 
 
public class MainActivity extends ActionBarActivity implements ActionBar.TabListener, AsyncRefreshDataListener {
 
 
    SectionsPagerAdapter mSectionsPagerAdapter;  
    ViewPager mViewPager;
 
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
 
        final ActionBar actionBar = getSupportActionBar();
        actionBar.setNavigationMode(ActionBar.NAVIGATION_MODE_TABS);
 
        mSectionsPagerAdapter = new SectionsPagerAdapter(getSupportFragmentManager());
 
        mViewPager = (ViewPager) findViewById(R.id.pager);
        mViewPager.setAdapter(mSectionsPagerAdapter);
 
 
        mViewPager.setOnPageChangeListener(new ViewPager.SimpleOnPageChangeListener() {
            @Override
            public void onPageSelected(int position) {
                actionBar.setSelectedNavigationItem(position);
            }
        });
 
        for (int i = 0; i < mSectionsPagerAdapter.getCount(); i++) {
            // Create a tab with text corresponding to the page title defined by
            // the adapter. Also specify this Activity object, which implements
            // the TabListener interface, as the callback (listener) for when
            // this tab is selected.
            actionBar.addTab(
                    actionBar.newTab()
                            .setText(mSectionsPagerAdapter.getPageTitle(i))
                            .setTabListener(this));
        }
    }
 
 
    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
 
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.main, menu);
        return true;
    }
 
    @Override
    public boolean onOptionsItemSelected(MenuItem item) {      
        int id = item.getItemId();
 
        switch (item.getItemId()) {
            case R.id.action_refresh:
                RefreshData();
                return true;
            case R.id.action_contact:
                Tools.EnvoiMailContact(this);
                return true;
            default:
                return super.onOptionsItemSelected(item);
        }
    }
 
    private void  RefreshData() {
        // Récupération des évènements
        AsyncRefreshDataLoader loader = null;
        try {
            loader = new AsyncRefreshDataLoader(new URL("*********************************"), this);
        } catch (MalformedURLException e) {
            e.printStackTrace();
        }
        loader.run();
    }
 
 
    @Override
    public void onTabSelected(ActionBar.Tab tab, FragmentTransaction fragmentTransaction) {      
        mViewPager.setCurrentItem(tab.getPosition());
    }  
 
    @Override
    public void chargementTermine(String contenu) {
 
        if (contenu != null) {
            // On récupére le flux et on ajoute les données en table
            try {
                JSONArray jso = new JSONArray(contenu);
 
                EvenementADO evntADO = new EvenementADO(this);
                evntADO.Open();
 
                int i;
                for (i = 0; i <= jso.length(); i++) {
                    evntADO.EvenementAdd(new EvenementEntity(0,
                            jso.getJSONObject(0).getString("titre"),
                            jso.getJSONObject(0).getString("ville"),
                            jso.getJSONObject(0).getString("adresse"),
                            jso.getJSONObject(0).getString("description"),
                            jso.getJSONObject(0).getString("dateDebut"),
                            jso.getJSONObject(0).getString("dateFin"),
                            jso.getJSONObject(0).getString("lien")));
                }
 
                evntADO.Close();
                mSectionsPagerAdapter.getItem(1).onResume();
 
            } catch (JSONException e) {
                e.printStackTrace();
            }
        }
    }
 
 
    public class SectionsPagerAdapter extends FragmentPagerAdapter {
 
        public SectionsPagerAdapter(FragmentManager fm) {
            super(fm);
        }
 
        @Override
        public Fragment getItem(int position) {
 
            switch (position) {
                case 0:
                    return PlaceholderFragmentIdentity.newInstance();
                case 1:
                    return PlaceholderFragmentEvnt.newInstance();            
 
            }
            return null;
        }
 
        @Override
        public int getCount() {
            return 2;
        }
 
        @Override
        public CharSequence getPageTitle(int position) {
            Locale l = Locale.getDefault();
            switch (position) {
                case 0:
                    return getString(R.string.title_section1).toUpperCase(l);
                case 1:
                    return getString(R.string.title_section2).toUpperCase(l);             
 
            }
            return null;
        }
    }
 
    /**
     * A placeholder fragment containing a simple view.
     */
    public static class PlaceholderFragmentEvnt extends Fragment
    {
 
        public static PlaceholderFragmentEvnt newInstance()
        {
            PlaceholderFragmentEvnt fragment = new PlaceholderFragmentEvnt();
            return fragment;
        }
 
        public PlaceholderFragmentEvnt()
        {
 
        }
 
 
        private View AfficheEvenementList(View rootView){
 
            ListView lvEvenement = (ListView) rootView.findViewById(R.id.lvEvnt);
 
            // On récupére la liste des évènements
            Cursor cur = getCursorEvenement();
 
            if ((cur != null) && (cur.getCount() != 0))
            {
                EvenementCursorAdapter filterAdapter = new EvenementCursorAdapter(getActivity(), R.layout.view_evenement, cur, new String[]{EvenementADO.COL_TITRE, EvenementADO.COL_VILLE, EvenementADO.COL_DATE_DEBUT}, new int[]{R.id.tvTitre, R.id.tvVille, R.id.tvDate}, 0);
                lvEvenement.setAdapter(filterAdapter);
 
                //Enfin on met un écouteur d'évènement sur notre listView
                lvEvenement.setOnItemClickListener(new AdapterView.OnItemClickListener() {
                    @Override
                    @SuppressWarnings("unchecked")
                    public void onItemClick(AdapterView<?> a, View v, int position, long id) {
                        Intent intent = new Intent(getActivity(), DetailEvenementActivity.class);
                        intent.putExtra("id", id);
                        startActivity(intent);
                    }
                });
            }
 
            return rootView;
        }
 
        @Override
        public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState)
        {
            View rootView = inflater.inflate(R.layout.fragment_evnt, container, false);         
            return AfficheEvenementList(rootView);        
        }
 
        // Initialisation et récupération des évènements
        private Cursor getCursorEvenement() {
            EvenementADO evntADO = new EvenementADO(getActivity());
            evntADO.Open();
            AjoutJeuDeTestProvisoire(evntADO);
            Cursor cur = evntADO.EvenementGetCursorAll();
            evntADO.Close();
            return cur;
        }          
    }
}

Dans la méthode chargementTermine(String contenu) qui est le callback la récupération async de mesdonnées sur un server, j'ai tenté de mettre à jours mon deuxième onglet avec un mSectionsPagerAdapter.getItem(1).onResume() mais cela ne fonctionne pas.

[andronull]

Dans ton ViewPager SectionsPagerAdapter tu ajout une method setArrayList

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
 
public void setArrayList(List<Item> ItemArray) {
		this.temArray = ItemArray;
		notifyDataSetChanged();
	}

puis

tu rempli l adapter a nouveau par ton evntADO

mSectionsPagerAdapter.setArrayList(evntADO )

puis tu reaffect l adapter a ton ViewPager

mViewPager.setAdapter(mSectionsPagerAdapter);

[andronull]

tu peux aussi utiliser un custom AsyncTaskLoader avec une implementation LoaderManager.LoaderCallbacks dans ton ListFragment

http://developer.android.com/referen...askLoader.html

[stelincat]

Bonjour et merci andronull,

J'ai essayer d'ajouter ta méthode setArrayList au SectionsPagerAdapter, mais la propriété itemArray n'existe pas sur le SectionsPagerAdapter

[andronull]

c est just un exemple tu remplace item par la classe model que tu utilise puis pour itemarray c est une variable que tu peux declarer celon ton code

exempl

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
private List<Model> ItemArray ;

[nidhalnsdev]

Bonjour,
Je pense que la meilleur solution dans ton cas est d'utiliser les callback au lieu des AsyncTask Standard.
Merci

[andronull]

voila un en exemple de ModeleLoader si tu n utilise pas de LoaderManager cursor

Loader assure l'exécution de requêtes sur un thread séparé, le suivi de la source de données pour les modifications, et délivrer de nouveaux résultats à un auditeur agréé (généralement le LoaderManager) lorsque des modifications sont détectées.


et ici un tres beau tuto pour Implementation Loaders
http://www.androiddesignpatterns.com...g-loaders.html

ref ModeleLOader

https://gist.github.com/blork/6081239

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
 
package ...;
 
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;
 
import android.content.ContentResolver;
import android.content.Context;
import android.content.SyncStatusObserver;
import android.database.ContentObserver;
import android.net.Uri;
import android.os.Handler;
import android.support.v4.content.AsyncTaskLoader;
 
import com.activeandroid.Model;
import com.activeandroid.content.ContentProvider;
import com.activeandroid.query.From;
import com.activeandroid.query.Select;
 
 
/**
 * The Class ModelLoader.
 * 
 * @param <T>
 *            the generic type
 */
public class ModelLoader<T extends Model> extends AsyncTaskLoader<List<T>>
{
	private ContentResolver mContentResolver;
	private ContentObserver mContentObserver;
	private From mQuery;
	private List<T> mResults;
	private Class<T> mClass;
	private Object mHandle;
	private boolean mUpdateOnRelationshipChanges;
 
 
	/**
         * Instantiates a new model loader. Will retrieve all models of the specified subclass. Will not
         * be reloaded on relationship changes.
         * 
         * @param context
         *            the model subclass you wish to query
         * @param clazz
         *            the clazz
         */
	public ModelLoader(Context context, Class<T> clazz)
	{
		this(context, clazz, null, false);
	}
 
 
	/**
         * Instantiates a new model loader. Will retrieve all models of the specified subclass.
         * 
         * @param context
         *            the context
         * @param clazz
         *            the model subclass you wish to query
         * @param updateOnRelationshipChanges
         *            if true, loader will updated when tables related to the one detected are changed
         */
	public ModelLoader(Context context, Class<T> clazz, boolean updateOnRelationshipChanges)
	{
		this(context, clazz, null, updateOnRelationshipChanges);
	}
 
 
	/**
         * Instantiates a new model loader.
         * 
         * @param context
         *            the context
         * @param clazz
         *            the model subclass you wish to query
         * @param from
         *            a select/from statement that will be executed to retrieve the objects
         * @param updateOnRelationshipChanges
         *            if true, loader will updated when tables related to the one detected are changed
         */
	public ModelLoader(Context context, Class<T> clazz, From from,
			boolean updateOnRelationshipChanges)
	{
		super(context);
		mQuery = from;
		mClass = clazz;
		mContentResolver = context.getContentResolver();
		mUpdateOnRelationshipChanges = updateOnRelationshipChanges;
	}
 
 
	/**
         * Called when there is new data to deliver to the client. The super class
         * will take care of delivering it; the implementation here just adds a
         * little more logic.
         * 
         * @param models
         *            the new models to be delivered
         */
	@Override
	public void deliverResult(List<T> models)
	{
		if (isReset())
		{
			// An async query came in while the loader is stopped. We
			// don't need the result.
			return;
		}
 
		mResults = models;
 
		if (isStarted())
		{
			// If the Loader is currently started, we can immediately
			// deliver its results.
			super.deliverResult(models);
		}
 
	}
 
 
	/**
         * This is where the bulk of our work is done. This function is called in a
         * background thread and should generate a new set of data to be published
         * by the loader.
         * 
         * @return the list
         */
	@Override
	public List<T> loadInBackground()
	{
		List<T> results;
 
		if (mQuery == null)
		{
			results = new Select().from(mClass)
					.execute();
		}
		else
		{
			results = mQuery.execute();
		}
 
		return results;
	}
 
 
	/**
         * Handles a request to completely reset the Loader.
         */
	@Override
	protected void onReset()
	{
		super.onReset();
 
		// Ensure the loader is stopped
		onStopLoading();
 
		mResults = null;
 
		// Stop monitoring for changes.
		if (mContentObserver != null)
		{
			mContentResolver.unregisterContentObserver(mContentObserver);
			ContentResolver.removeStatusChangeListener(mHandle);
			mHandle = null;
			mContentObserver = null;
		}
	}
 
 
	/**
         * Handles a request to start the Loader.
         */
	@Override
	protected void onStartLoading()
	{
		if (mResults != null)
		{
			// If we currently have a result available, deliver it
			// immediately.
			deliverResult(mResults);
		}
 
		// Start watching for changes in the job data.
		if (mContentObserver == null)
		{
			mContentObserver = new ContentObserver(new Handler(getContext().getMainLooper()))
			{
 
				@Override
				public void onChange(boolean selfChange)
				{
					onChange(selfChange, null);
				}
 
 
				@Override
				public void onChange(boolean selfChange, Uri uri)
				{
					onContentChanged();
				}
			};
 
			SyncStatusObserver statusObserver = new SyncStatusObserver()
			{
 
				@Override
				public void onStatusChanged(int which)
				{
					onContentChanged();
				}
			};
 
			mHandle = ContentResolver.addStatusChangeListener(
					ContentResolver.SYNC_OBSERVER_TYPE_ACTIVE, statusObserver);
 
			mContentResolver.registerContentObserver(ContentProvider.createUri(mClass, null), true,
					mContentObserver);
 
			// Register for updates from related tables
			if (mUpdateOnRelationshipChanges)
			{
				Field[] fields = mClass.getDeclaredFields();
				for (Field field : fields)
				{
					Class<?> clazz = field.getType();
					if (Model.class.isAssignableFrom(clazz))
					{
						mContentResolver.registerContentObserver(
								ContentProvider.createUri(clazz.asSubclass(Model.class), null),
								true, mContentObserver);
					}
				}
 
				Method[] methods = mClass.getDeclaredMethods();
				for (Method method : methods)
				{
					Class<?> returnClass = method.getReturnType();
					if (Model.class.isAssignableFrom(returnClass))
					{
						mContentResolver.registerContentObserver(
								ContentProvider.createUri(returnClass.asSubclass(Model.class), null),
								true, mContentObserver);
					}
					else
					{
						Type type = method.getGenericReturnType();
						if (type instanceof ParameterizedType)
						{
							ParameterizedType parameterizedType = (ParameterizedType) type;
							for (Type actualType : parameterizedType.getActualTypeArguments())
							{
								Class<T> genericClass = (Class<T>) actualType;
								if (Model.class.isAssignableFrom(genericClass))
								{
									mContentResolver.registerContentObserver(
											ContentProvider.createUri(
													genericClass.asSubclass(Model.class), null),
											true, mContentObserver);
								}
							}
						}
					}
				}
 
			}
		}
 
		if (takeContentChanged() || (mResults == null))
		{
			// If the data has changed since the last time it was loaded
			// or is not currently available, start a load.
			forceLoad();
		}
	}
 
 
	/**
         * Handles a request to stop the Loader.
         */
	@Override
	protected void onStopLoading()
	{
		// Attempt to cancel the current load task if possible.
		cancelLoad();
	}
}