android_5.0_viewdemo

In RxJava, the relationship between an Observable and a Subscriber (or Observer) is established through a two-step process: creation and subscription.

1. create(): This method creates an Observable instance and attaches an OnSubscribe object to it. The OnSubscribe object contains the logic that defines how data is emitted.
2. subscribe(): This method triggers the execution. When you call subscribe(subscriber), RxJava executes the call(subscriber) method stored within the Observable's onSubscribe property. This call method is what actually invokes the onNext, onCompleted, and onError methods of your subscriber.

Crucial Execution Order: The subscribe() method initiates the process, but the actual logic inside the OnSubscribe.call() method (where your data emission happens) is executed as a result of the subscription. In a synchronous setup, the subscribe call will block until the call method completes its execution.

// 1. Create the Observable
Observable<String> observable = Observable.create(new Observable.OnSubscribe<String>() {
    @Override
    public void call(Subscriber<? super String> subscriber) {
        subscriber.onNext("Hello");
        subscriber.onNext("World");
        subscriber.onCompleted();
        Log.i("Execution Order", " call completed ");
    }
});

// 2. Subscribe to trigger the logic
observable.subscribe(new Observer<String>() {
    @Override
    public void onNext(String s) {
        Log.i("onNext", s);
    }

    @Override
    public void onCompleted() {
        Log.i("onCompleted", "done");
    }

    @Override
    public void onError(Throwable e) {
        Log.i("onError", e.toString());
    }
});

For extremely complex, deeply nested JSON structures where creating full Bean models is impractical or inefficient, use JsonReader. This approach is similar to XML parsing: you navigate the JSON tree node-by-node based on keys.

Mental Model:

• Use beginObject() and endObject() to enter and exit JSON objects.
• Use beginArray() and endArray() for arrays.
• Use nextName() to retrieve the current key/tag.
• Use nextString(), nextInt(), etc., to retrieve values.
• Use skipValue() to ignore fields you don't care about, which prevents unnecessary processing.

Warning: This method is more verbose and requires manual management of the parsing state, but it is highly efficient for selective parsing.

/**
 * Example of manual node-based parsing with JsonReader
 */
private void parseComplexJArrayByReader() throws IOException {
    String strByJson = "...json_string...";
    JsonReader reader = new JsonReader(new StringReader(strByJson));
    try {
        reader.beginObject();
        String tagName = reader.nextName();
        if (tagName.equals("group")) {
            readGroup(reader);
        }
        reader.endObject();
    } finally {
        reader.close();
    }
}

private void readGroup(JsonReader reader) throws IOException {
    reader.beginObject();
    while (reader.hasNext()) {
        String tagName = reader.nextName();
        if (tagName.equals("user")) {
            readUser(reader);
        } else if (tagName.equals("info")) {
            readInfo(reader);
        } else {
            reader.skipValue(); // Skip unknown nodes
        }
    }
    reader.endObject();
}

private void readUser(JsonReader reader) throws IOException {
    reader.beginObject();
    while (reader.hasNext()) {
        String tag = reader.nextName();
        if (tag.equals("name")) {
            String name = reader.nextString();
            // Use name...
        } else if (tag.equals("age")) {
            String age = reader.nextString();
            // Use age...
        } else {
            reader.skipValue(); // Skip irrelevant fields
        }
    }
    reader.endObject();
}

A CommonViewHolder uses a SparseArray<View> to cache views by their ID, reducing the need for repeated findViewById calls. It manages the lifecycle of a convertView and provides a fluent API for setting view properties.

Key Responsibilities:

• Caching: Uses SparseArray to store and retrieve views by ID.
• Lifecycle: Handles inflation of the layout and manages the convertView via setTag.
• Fluent API: Supports method chaining (e.g., .setText(...).setImageResource(...)) to simplify view updates.

Core Methods:

• get(Context, View, ViewGroup, int, int): Static method to retrieve an existing ViewHolder from a convertView tag or create a new one.
• getView<T>(int viewId): Retrieves a view of type T from the cache or performs a findViewById if not cached.
• getConvertView(): Returns the underlying View for use in the Adapter's getView method.

// Example of using CommonViewHolder in an Adapter's getView method
@Override
public View getView(int position, View convertView, ViewGroup parent) {
    // 1. Get the ViewHolder
    CommonViewHolder viewHolder = CommonViewHolder.get(context, convertView, parent, R.layout.item_list, position);

    NewsBean bean = list.get(position);

    // 2. Set content using fluent API
    viewHolder.setText(R.id.tv_title, bean.getTitle())
            .setText(R.id.tv_desc, bean.getDesc())
            .setText(R.id.tv_time, bean.getTime())
            .setText(R.id.tv_phone, bean.getPhone());

    // 3. Return the recycled view
    return viewHolder.getConvertView();
}