Douya

https://github.com/zhanghai/douya
Admin
开源的 Material Design 豆瓣客户端（A Material Design app for douban.com）
Tokens:1,469
Snippets:5
Trust Score:8.1
Update:1 year ago
Show doc for...
Tokens:
Raw
### Android Gradle Build Configuration

Source: https://github.com/zhanghai/douya/blob/master/README.md

This snippet shows the basic steps for manually building the Douya Android project using Gradle. It includes the creation of a `signing.properties` file for signing the APK and the Gradle build command.

```ini
[signing]
storeFile=YOUR_STORE_FILE
storePassword=
keyAlias=
keyPassword=
```

```bash
./gradlew build
```

--------------------------------

### Bash Scripts for SVG Generation

Source: https://github.com/zhanghai/douya/blob/master/README.md

This section describes bash scripts used to generate template SVG assets for optimizing Android application startup speed. These scripts cater to different screen sizes and system versions, creating compatible preview images.

```bash
#!/bin/bash

# Example script for generating SVG assets
# Details can be found at https://github.com/zhanghai/AndroidSVGScripts
```

--------------------------------

### Douya UI Implementation with Material Design (Java/Kotlin)

Source: https://github.com/zhanghai/douya/blob/master/README.md

This snippet demonstrates the UI layer implementation using Android's Support Library components like AppCompat, Design, CardView, and RecyclerView to achieve Material Design. It also highlights the use of Shared Element Transitions for smooth animations on Android 5.0+ and a typical Activity/Fragment/Adapter structure for UI components.

```java
public class BroadcastAdapter extends RecyclerView.Adapter<BroadcastAdapter.ViewHolder> {

    private List<BroadcastItem> broadcastList;
    private Activity activity;

    public BroadcastAdapter(Activity activity, List<BroadcastItem> broadcastList) {
        this.activity = activity;
        this.broadcastList = broadcastList;
    }

    @NonNull
    @Override
    public ViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
        View view = LayoutInflater.from(parent.getContext()).inflate(R.layout.item_broadcast, parent, false);
        return new ViewHolder(view);
    }

    @Override
    public void onBindViewHolder(@NonNull ViewHolder holder, int position) {
        BroadcastItem item = broadcastList.get(position);
        // Bind data to views
        holder.textViewContent.setText(item.getContent());
        // Load user avatar using Glide
        Glide.with(activity)
             .load(item.getUserAvatarUrl())
             .into(holder.imageViewAvatar);

        // Set up click listener for Shared Element Transition
        holder.itemView.setOnClickListener(v -> {
            Intent intent = new Intent(activity, BroadcastDetailActivity.class);
            intent.putExtra(BroadcastDetailActivity.EXTRA_BROADCAST_ID, item.getId());

            // Define shared elements
            ActivityOptionsCompat options = ActivityOptionsCompat.makeSceneTransitionAnimation(
                activity, 
                holder.imageViewAvatar, "user_avatar_transition"
            );
            activity.startActivity(intent, options.toBundle());
        });
    }

    @Override
    public int getItemCount() {
        return broadcastList.size();
    }

    public static class ViewHolder extends RecyclerView.ViewHolder {
        ImageView imageViewAvatar;
        TextView textViewContent;
        // Other views

        public ViewHolder(View itemView) {
            super(itemView);
            imageViewAvatar = itemView.findViewById(R.id.image_view_avatar);
            textViewContent = itemView.findViewById(R.id.text_view_content);
            // Initialize other views
        }
    }
}

public class BroadcastDetailActivity extends AppCompatActivity {
    public static final String EXTRA_BROADCAST_ID = "broadcast_id";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_broadcast_detail);

        // Enable transitions
        getWindow().requestFeature(Window.FEATURE_CONTENT_TRANSITIONS);
        // Setup enter and exit transitions
        // ...

        String broadcastId = getIntent().getStringExtra(EXTRA_BROADCAST_ID);
        // Fetch and display broadcast details
    }
}

```

--------------------------------

### Douya Network and Data Handling (Java/Kotlin)

Source: https://github.com/zhanghai/douya/blob/master/README.md

This snippet showcases the data layer implementation for the Douya application. It uses Retrofit for network requests, Gson for JSON parsing, Glide for image loading, DiskLRUCache for data caching, and EventBus for inter-component communication. This approach centralizes data fetching, parsing, and synchronization.

```java
public class NetworkManager {
    private Retrofit retrofit;
    private DoubanApiService apiService;

    public NetworkManager() {
        retrofit = new Retrofit.Builder()
            .baseUrl("https://api.douban.com/")
            .addConverterFactory(GsonConverterFactory.create())
            .client(OkHttpClientProvider.getOkHttpClient())
            .build();
        apiService = retrofit.create(DoubanApiService.class);
    }

    public DoubanApiService getApiService() {
        return apiService;
    }
}

public class CacheManager {
    private DiskLruCache diskCache;

    public void initCache(Context context) {
        // Initialize DiskLruCache with appropriate size and file count
    }

    public void put(String key, String data) {
        // Asynchronous write to DiskLruCache
    }

    public String get(String key) {
        // Asynchronous read from DiskLruCache
        return null;
    }
}

public class EventBusManager {
    private EventBus eventBus;

    public void register(Object subscriber) {
        eventBus.register(subscriber);
    }

    public void unregister(Object subscriber) {
        eventBus.unregister(subscriber);
    }

    public void post(Object event) {
        eventBus.post(event);
    }
}

// Example usage in an Activity or Fragment
public class MainActivity extends AppCompatActivity {
    private NetworkManager networkManager;
    private CacheManager cacheManager;
    private EventBusManager eventBusManager;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        // ...
        networkManager = new NetworkManager();
        cacheManager = new CacheManager();
        cacheManager.initCache(this);
        eventBusManager = new EventBusManager();
        eventBusManager.register(this);
        // ...
    }

    // Method to fetch data
    private void fetchData() {
        networkManager.getApiService().getBroadcasts().enqueue(new Callback<BroadcastResponse>() {
            @Override
            public void onResponse(Call<BroadcastResponse> call, Response<BroadcastResponse> response) {
                if (response.isSuccessful() && response.body() != null) {
                    BroadcastResponse data = response.body();
                    cacheManager.put("broadcasts", new Gson().toJson(data));
                    eventBusManager.post(new DataUpdateEvent(data));
                }
            }

            @Override
            public void onFailure(Call<BroadcastResponse> call, Throwable t) {
                // Handle error
            }
        });
    }

    @Subscribe
    public void onDataUpdate(DataUpdateEvent event) {
        // Update UI with the new data
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        eventBusManager.unregister(this);
    }
}

```

--------------------------------

### Android Screen Rotation State Preservation

Source: https://github.com/zhanghai/douya/blob/master/README.md

This snippet details how the Douya project handles Android's screen rotation, which typically destroys and recreates Activities and Views. It explains the use of `onSaveViewState()` and `onRestoreViewState()` for view state, a `RetainDataFragment` for data persistence, and a `RequestFragment` for maintaining network requests across Activity reconstructions.

```java
public class RetainDataFragment extends Fragment {
    // ... data retention logic ...
}

public class RequestFragment extends Fragment {
    // ... network request persistence logic ...
}
```
Tokens:
Raw