DelayingSuggestionsAdapter.java revision 7a0c3a7c6fdabce949b59e0a2c6ec1d44a140c24 
1/*
2 * Copyright (C) 2009 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package com.android.quicksearchbox.ui;
18
19import com.android.quicksearchbox.Promoter;
20import com.android.quicksearchbox.SuggestionCursor;
21import com.android.quicksearchbox.SuggestionPosition;
22import com.android.quicksearchbox.Suggestions;
23
24import android.database.DataSetObserver;
25import android.util.Log;
26import android.view.View.OnFocusChangeListener;
27
28/**
29 * A {@link SuggestionsListAdapter} that doesn't expose the new suggestions
30 * until there are some results to show.
31 */
32public class DelayingSuggestionsAdapter<A> implements SuggestionsAdapter<A> {
33
34    private static final boolean DBG = false;
35    private static final String TAG = "QSB.DelayingSuggestionsAdapter";
36
37    private DataSetObserver mPendingDataSetObserver;
38
39    private Suggestions mPendingSuggestions;
40
41    private final SuggestionsAdapterBase<A> mDelayedAdapter;
42
43    public DelayingSuggestionsAdapter(SuggestionsAdapterBase<A> delayed) {
44        mDelayedAdapter = delayed;
45    }
46
47    public void close() {
48        setPendingSuggestions(null);
49        mDelayedAdapter.close();
50    }
51
52    @Override
53    public void setSuggestions(Suggestions suggestions) {
54        if (suggestions == null) {
55            mDelayedAdapter.setSuggestions(null);
56            setPendingSuggestions(null);
57            return;
58        }
59        if (shouldPublish(suggestions)) {
60            if (DBG) Log.d(TAG, "Publishing suggestions immediately: " + suggestions);
61            mDelayedAdapter.setSuggestions(suggestions);
62            // Clear any old pending suggestions.
63            setPendingSuggestions(null);
64        } else {
65            if (DBG) Log.d(TAG, "Delaying suggestions publishing: " + suggestions);
66            setPendingSuggestions(suggestions);
67        }
68    }
69
70    /**
71     * Gets whether the given suggestions are non-empty for the selected source.
72     */
73    private boolean shouldPublish(Suggestions suggestions) {
74        if (suggestions.isDone()) return true;
75        SuggestionCursor cursor = mDelayedAdapter.getPromoted(suggestions);
76        return cursor != null && cursor.getCount() > 0;
77    }
78
79    private void setPendingSuggestions(Suggestions suggestions) {
80        if (mPendingSuggestions == suggestions) {
81            return;
82        }
83        if (mDelayedAdapter.isClosed()) {
84            if (suggestions != null) {
85                suggestions.release();
86            }
87            return;
88        }
89        if (mPendingDataSetObserver == null) {
90            mPendingDataSetObserver = new PendingSuggestionsObserver();
91        }
92        if (mPendingSuggestions != null) {
93            mPendingSuggestions.unregisterDataSetObserver(mPendingDataSetObserver);
94            // Close old suggestions, but only if they are not also the current
95            // suggestions.
96            if (mPendingSuggestions != getSuggestions()) {
97                mPendingSuggestions.release();
98            }
99        }
100        mPendingSuggestions = suggestions;
101        if (mPendingSuggestions != null) {
102            mPendingSuggestions.registerDataSetObserver(mPendingDataSetObserver);
103        }
104    }
105
106    protected void onPendingSuggestionsChanged() {
107        if (DBG) {
108            Log.d(TAG, "onPendingSuggestionsChanged(), mPendingSuggestions="
109                    + mPendingSuggestions);
110        }
111        if (shouldPublish(mPendingSuggestions)) {
112            if (DBG) Log.d(TAG, "Suggestions now available, publishing: " + mPendingSuggestions);
113            mDelayedAdapter.setSuggestions(mPendingSuggestions);
114            // The suggestions are no longer pending.
115            setPendingSuggestions(null);
116        }
117    }
118
119    private class PendingSuggestionsObserver extends DataSetObserver {
120        @Override
121        public void onChanged() {
122            onPendingSuggestionsChanged();
123        }
124    }
125
126    public A getListAdapter() {
127        return mDelayedAdapter.getListAdapter();
128    }
129
130    public SuggestionCursor getCurrentPromotedSuggestions() {
131        return mDelayedAdapter.getCurrentPromotedSuggestions();
132    }
133
134    public Suggestions getSuggestions() {
135        return mDelayedAdapter.getSuggestions();
136    }
137
138    public SuggestionPosition getSuggestion(long suggestionId) {
139        return mDelayedAdapter.getSuggestion(suggestionId);
140    }
141
142    public void onSuggestionClicked(long suggestionId) {
143        mDelayedAdapter.onSuggestionClicked(suggestionId);
144    }
145
146    public void onSuggestionQueryRefineClicked(long suggestionId) {
147        mDelayedAdapter.onSuggestionQueryRefineClicked(suggestionId);
148    }
149
150    public void onSuggestionQuickContactClicked(long suggestionId) {
151        mDelayedAdapter.onSuggestionQuickContactClicked(suggestionId);
152    }
153
154    public void onSuggestionRemoveFromHistoryClicked(long suggestionId) {
155        mDelayedAdapter.onSuggestionRemoveFromHistoryClicked(suggestionId);
156    }
157
158    public void setMaxPromoted(int maxPromoted) {
159        mDelayedAdapter.setMaxPromoted(maxPromoted);
160    }
161
162    public void setOnFocusChangeListener(OnFocusChangeListener l) {
163        mDelayedAdapter.setOnFocusChangeListener(l);
164    }
165
166    @Override
167    public void setPromoter(Promoter promoter) {
168        mDelayedAdapter.setPromoter(promoter);
169    }
170
171    public void setSuggestionAdapterChangeListener(SuggestionsAdapterChangeListener l) {
172        mDelayedAdapter.setSuggestionAdapterChangeListener(l);
173    }
174
175    public void setSuggestionClickListener(SuggestionClickListener listener) {
176        mDelayedAdapter.setSuggestionClickListener(listener);
177    }
178
179    public void setIcon1Enabled(boolean enabled) {
180        mDelayedAdapter.setIcon1Enabled(enabled);
181    }
182
183    @Override
184    public boolean isEmpty() {
185        return mDelayedAdapter.isEmpty();
186    }
187
188}
189