mirror of
https://github.com/samuelclay/NewsBlur.git
synced 2025-08-05 16:58:59 +00:00
6d1b89040f
- Confirmed that the code already added to open in Edge works. - Added an option to open in Brave while I was there.
4515 lines
194 KiB
Objective-C
4515 lines
194 KiB
Objective-C
// NewsBlurAppDelegate.m
|
||
// NewsBlur
|
||
//
|
||
// Created by Samuel Clay on 6/16/10.
|
||
// Copyright NewsBlur 2010. All rights reserved.
|
||
//
|
||
|
||
#import "NewsBlurAppDelegate.h"
|
||
#import "NewsBlurViewController.h"
|
||
#import "NBContainerViewController.h"
|
||
#import "FeedDetailViewController.h"
|
||
#import "DashboardViewController.h"
|
||
#import "MarkReadMenuViewController.h"
|
||
#import "FeedsMenuViewController.h"
|
||
#import "StoryDetailViewController.h"
|
||
#import "StoryPageControl.h"
|
||
#import "FirstTimeUserViewController.h"
|
||
#import "FriendsListViewController.h"
|
||
#import "LoginViewController.h"
|
||
#import "AddSiteViewController.h"
|
||
#import "MoveSiteViewController.h"
|
||
#import "TrainerViewController.h"
|
||
#import "NotificationsViewController.h"
|
||
#import "UserTagsViewController.h"
|
||
#import "OriginalStoryViewController.h"
|
||
#import "ShareViewController.h"
|
||
#import "FontSettingsViewController.h"
|
||
#import "FeedChooserViewController.h"
|
||
#import "UserProfileViewController.h"
|
||
#import "PremiumViewController.h"
|
||
#import "InteractionsModule.h"
|
||
#import "ActivityModule.h"
|
||
#import "FirstTimeUserViewController.h"
|
||
#import "FirstTimeUserAddSitesViewController.h"
|
||
#import "FirstTimeUserAddFriendsViewController.h"
|
||
#import "FirstTimeUserAddNewsBlurViewController.h"
|
||
#import "TUSafariActivity.h"
|
||
#import "ARChromeActivity.h"
|
||
#import "NBCopyLinkActivity.h"
|
||
#import "MBProgressHUD.h"
|
||
#import "Utilities.h"
|
||
#import "StringHelper.h"
|
||
#import "AuthorizeServicesViewController.h"
|
||
#import "Reachability.h"
|
||
#import "FMDatabase.h"
|
||
#import "FMDatabaseQueue.h"
|
||
#import "FMDatabaseAdditions.h"
|
||
#import "SBJson4.h"
|
||
#import "NSObject+SBJSON.h"
|
||
#import "IASKAppSettingsViewController.h"
|
||
#import "OfflineSyncUnreads.h"
|
||
#import "OfflineFetchStories.h"
|
||
#import "OfflineFetchText.h"
|
||
#import "OfflineFetchImages.h"
|
||
#import "OfflineCleanImages.h"
|
||
#import "NBBarButtonItem.h"
|
||
#import "PINCache.h"
|
||
#import "StoriesCollection.h"
|
||
#import "NSString+HTML.h"
|
||
#import "UIView+ViewController.h"
|
||
#import "NBURLCache.h"
|
||
#import "NBActivityItemSource.h"
|
||
#import "NSNull+JSON.h"
|
||
#import "UISearchBar+Field.h"
|
||
#import "UIViewController+HidePopover.h"
|
||
#import "PINCache.h"
|
||
#import <float.h>
|
||
#import <UserNotifications/UserNotifications.h>
|
||
#import <Intents/Intents.h>
|
||
#import <CoreSpotlight/CoreSpotlight.h>
|
||
#import <CoreServices/CoreServices.h>
|
||
|
||
@interface NewsBlurAppDelegate () <UIViewControllerTransitioningDelegate, UNUserNotificationCenterDelegate>
|
||
|
||
@property (nonatomic, strong) NSString *cachedURL;
|
||
@property (nonatomic, strong) UIApplicationShortcutItem *launchedShortcutItem;
|
||
@property (nonatomic, strong) SFSafariViewController *safariViewController;
|
||
@property (nonatomic, strong) NSMutableDictionary<NSString *, NSNumber *> *networkBackgroundTasks;
|
||
|
||
@end
|
||
|
||
@implementation NewsBlurAppDelegate
|
||
|
||
#define CURRENT_DB_VERSION 37
|
||
|
||
#define CURRENT_STATE_VERSION 1
|
||
|
||
@synthesize window;
|
||
|
||
@synthesize ftuxNavigationController;
|
||
@synthesize navigationController;
|
||
@synthesize modalNavigationController;
|
||
@synthesize shareNavigationController;
|
||
@synthesize trainNavigationController;
|
||
@synthesize notificationsNavigationController;
|
||
@synthesize premiumNavigationController;
|
||
@synthesize userProfileNavigationController;
|
||
@synthesize masterContainerViewController;
|
||
@synthesize dashboardViewController;
|
||
@synthesize feedsViewController;
|
||
@synthesize feedsMenuViewController;
|
||
@synthesize feedDetailViewController;
|
||
@synthesize friendsListViewController;
|
||
@synthesize fontSettingsViewController;
|
||
@synthesize storyDetailViewController;
|
||
@synthesize storyPageControl;
|
||
@synthesize shareViewController;
|
||
@synthesize loginViewController;
|
||
@synthesize addSiteViewController;
|
||
@synthesize moveSiteViewController;
|
||
@synthesize trainerViewController;
|
||
@synthesize notificationsViewController;
|
||
@synthesize userTagsViewController;
|
||
@synthesize originalStoryViewController;
|
||
@synthesize originalStoryViewNavController;
|
||
@synthesize userProfileViewController;
|
||
@synthesize preferencesViewController;
|
||
@synthesize premiumViewController;
|
||
|
||
@synthesize firstTimeUserViewController;
|
||
@synthesize firstTimeUserAddSitesViewController;
|
||
@synthesize firstTimeUserAddFriendsViewController;
|
||
@synthesize firstTimeUserAddNewsBlurViewController;
|
||
|
||
@synthesize networkManager;
|
||
@synthesize feedDetailPortraitYCoordinate;
|
||
@synthesize cachedFavicons;
|
||
@synthesize cachedStoryImages;
|
||
@synthesize activeUsername;
|
||
@synthesize activeUserProfileId;
|
||
@synthesize activeUserProfileName;
|
||
@synthesize hasNoSites;
|
||
@synthesize isTryFeedView;
|
||
|
||
@synthesize inFindingStoryMode;
|
||
@synthesize hasLoadedFeedDetail;
|
||
@synthesize tryFeedStoryId;
|
||
@synthesize tryFeedFeedId;
|
||
@synthesize tryFeedCategory;
|
||
@synthesize popoverHasFeedView;
|
||
@synthesize inFeedDetail;
|
||
@synthesize inStoryDetail;
|
||
@synthesize isPresentingActivities;
|
||
@synthesize activeComment;
|
||
@synthesize activeShareType;
|
||
|
||
@synthesize storiesCollection;
|
||
|
||
@synthesize activeStory;
|
||
@synthesize savedStoriesCount;
|
||
@synthesize originalStoryCount;
|
||
@synthesize selectedIntelligence;
|
||
@synthesize activeOriginalStoryURL;
|
||
@synthesize recentlyReadStories;
|
||
@synthesize recentlyReadFeeds;
|
||
@synthesize readStories;
|
||
@synthesize unreadStoryHashes;
|
||
@synthesize unsavedStoryHashes;
|
||
@synthesize folderCountCache;
|
||
@synthesize collapsedFolders;
|
||
@synthesize fontDescriptorTitleSize;
|
||
|
||
@synthesize dictFolders;
|
||
@synthesize dictFeeds;
|
||
@synthesize dictActiveFeeds;
|
||
@synthesize dictSocialFeeds;
|
||
@synthesize dictSavedStoryTags;
|
||
@synthesize dictSocialProfile;
|
||
@synthesize dictUserProfile;
|
||
@synthesize dictSocialServices;
|
||
@synthesize dictUnreadCounts;
|
||
@synthesize dictTextFeeds;
|
||
@synthesize isPremium;
|
||
@synthesize premiumExpire;
|
||
@synthesize userInteractionsArray;
|
||
@synthesize userActivitiesArray;
|
||
@synthesize dictFoldersArray;
|
||
@synthesize notificationFeedIds;
|
||
|
||
@synthesize database;
|
||
@synthesize categories;
|
||
@synthesize categoryFeeds;
|
||
@synthesize activeCachedImages;
|
||
@synthesize hasQueuedReadStories;
|
||
@synthesize offlineQueue;
|
||
@synthesize offlineCleaningQueue;
|
||
@synthesize backgroundCompletionHandler;
|
||
@synthesize cacheImagesOperationQueue;
|
||
|
||
@synthesize totalUnfetchedStoryCount;
|
||
@synthesize remainingUnfetchedStoryCount;
|
||
@synthesize latestFetchedStoryDate;
|
||
@synthesize latestCachedImageDate;
|
||
@synthesize totalUncachedImagesCount;
|
||
@synthesize remainingUncachedImagesCount;
|
||
|
||
+ (NewsBlurAppDelegate*) sharedAppDelegate {
|
||
return (NewsBlurAppDelegate*) [UIApplication sharedApplication].delegate;
|
||
}
|
||
|
||
- (BOOL)application:(UIApplication *)application willFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
|
||
[self registerDefaultsFromSettingsBundle];
|
||
|
||
self.navigationController.delegate = self;
|
||
self.navigationController.viewControllers = [NSArray arrayWithObject:self.feedsViewController];
|
||
self.storiesCollection = [StoriesCollection new];
|
||
|
||
if (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad) {
|
||
self.window.rootViewController = self.masterContainerViewController;
|
||
} else {
|
||
self.window.rootViewController = self.navigationController;
|
||
}
|
||
|
||
[self clearNetworkManager];
|
||
|
||
[window makeKeyAndVisible];
|
||
|
||
[[ThemeManager themeManager] prepareForWindow:self.window];
|
||
|
||
[self createDatabaseConnection];
|
||
[self.cachedStoryImages removeAllObjects:nil];
|
||
[feedsViewController loadOfflineFeeds:NO];
|
||
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,
|
||
(unsigned long)NULL), ^(void) {
|
||
[self setupReachability];
|
||
cacheImagesOperationQueue = [NSOperationQueue new];
|
||
if (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad) {
|
||
cacheImagesOperationQueue.maxConcurrentOperationCount = 2;
|
||
} else {
|
||
cacheImagesOperationQueue.maxConcurrentOperationCount = 1;
|
||
}
|
||
});
|
||
|
||
// [self showFirstTimeUser];
|
||
|
||
cachedFavicons = [[PINCache alloc] initWithName:@"NBFavicons"];
|
||
cachedFavicons.memoryCache.removeAllObjectsOnEnteringBackground = NO;
|
||
cachedStoryImages = [[PINCache alloc] initWithName:@"NBStoryImages"];
|
||
cachedStoryImages.memoryCache.removeAllObjectsOnEnteringBackground = NO;
|
||
isPremium = NO;
|
||
premiumExpire = 0;
|
||
|
||
NBURLCache *urlCache = [[NBURLCache alloc] init];
|
||
[NSURLCache setSharedURLCache:urlCache];
|
||
// Uncomment below line to test image caching
|
||
// [[NSURLCache sharedURLCache] removeAllCachedResponses];
|
||
|
||
return YES;
|
||
}
|
||
|
||
- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
|
||
if ([UIApplicationShortcutItem class] && launchOptions[UIApplicationLaunchOptionsShortcutItemKey]) {
|
||
self.launchedShortcutItem = launchOptions[UIApplicationLaunchOptionsShortcutItemKey];
|
||
return NO;
|
||
}
|
||
|
||
if (launchOptions[UIApplicationLaunchOptionsRemoteNotificationKey]) {
|
||
NSDictionary *notification = launchOptions[UIApplicationLaunchOptionsRemoteNotificationKey];
|
||
[self processNotification:notification
|
||
action:@"com.apple.UNNotificationDefaultActionIdentifier"
|
||
withCompletionHandler:nil];
|
||
}
|
||
|
||
return YES;
|
||
}
|
||
|
||
- (void)applicationDidBecomeActive:(UIApplication *)application {
|
||
if (self.launchedShortcutItem) {
|
||
[self handleShortcutItem:self.launchedShortcutItem];
|
||
self.launchedShortcutItem = nil;
|
||
}
|
||
|
||
if (storyPageControl.temporarilyMarkedUnread && [storiesCollection isStoryUnread:activeStory]) {
|
||
[storiesCollection markStoryRead:activeStory];
|
||
[storiesCollection syncStoryAsRead:activeStory];
|
||
storyPageControl.temporarilyMarkedUnread = NO;
|
||
|
||
[self.feedDetailViewController reloadData];
|
||
[self.storyPageControl refreshHeaders];
|
||
}
|
||
}
|
||
|
||
- (void)applicationWillResignActive:(UIApplication *)application {
|
||
[self.feedsViewController refreshHeaderCounts];
|
||
}
|
||
|
||
- (void)applicationWillTerminate:(UIApplication *)application {
|
||
[self.feedsViewController refreshHeaderCounts];
|
||
}
|
||
|
||
- (void)applicationDidEnterBackground:(UIApplication *)application {
|
||
[self.feedsViewController refreshHeaderCounts];
|
||
}
|
||
|
||
- (BOOL)application:(UIApplication *)application shouldSaveApplicationState:(NSCoder *)coder {
|
||
return YES;
|
||
}
|
||
|
||
- (void)application:(UIApplication *)application willEncodeRestorableStateWithCoder:(NSCoder *)coder {
|
||
[coder encodeInteger:CURRENT_STATE_VERSION forKey:@"version"];
|
||
[coder encodeObject:[NSDate date] forKey:@"last_saved_state_date"];
|
||
}
|
||
|
||
- (BOOL)application:(UIApplication *)application shouldRestoreApplicationState:(NSCoder *)coder {
|
||
NSUserDefaults *preferences = [NSUserDefaults standardUserDefaults];
|
||
NSString *option = [preferences stringForKey:@"restore_state"];
|
||
|
||
if ([option isEqualToString:@"never"]) {
|
||
return NO;
|
||
} else if ([option isEqualToString:@"always"]) {
|
||
return YES;
|
||
}
|
||
|
||
NSTimeInterval daysInterval = 60 * 60;
|
||
NSTimeInterval limitInterval = option.doubleValue * daysInterval;
|
||
NSInteger version = [coder decodeIntegerForKey:@"version"];
|
||
NSDate *lastSavedDate = [coder decodeObjectOfClass:[NSDate class] forKey:@"last_saved_state_date"];
|
||
|
||
if (limitInterval == 0) {
|
||
limitInterval = 24 * daysInterval;
|
||
}
|
||
|
||
if (version > CURRENT_STATE_VERSION || lastSavedDate == nil) {
|
||
return NO;
|
||
}
|
||
|
||
NSTimeInterval savedInterval = -[lastSavedDate timeIntervalSinceNow];
|
||
|
||
return savedInterval < limitInterval;
|
||
}
|
||
|
||
- (UIViewController *)application:(UIApplication *)application viewControllerWithRestorationIdentifierPath:(NSArray<NSString *> *)identifierComponents coder:(NSCoder *)coder {
|
||
NSString *identifier = identifierComponents.lastObject;
|
||
|
||
if ([identifier isEqualToString:@"MainNavigation"]) {
|
||
return self.navigationController;
|
||
} else if ([identifier isEqualToString:@"FeedsView"]) {
|
||
return self.feedsViewController;
|
||
} else if ([identifier isEqualToString:@"FeedDetailView"]) {
|
||
return self.feedDetailViewController;
|
||
} else if ([identifier isEqualToString:@"StoryPageControl"]) {
|
||
return self.storyPageControl;
|
||
} else if ([identifier isEqualToString:@"ContainerView"]) {
|
||
return self.masterContainerViewController;
|
||
} else {
|
||
return nil;
|
||
}
|
||
}
|
||
|
||
- (void)application:(UIApplication *)application didDecodeRestorableStateWithCoder:(NSCoder *)coder {
|
||
// All done; could do any cleanup here
|
||
}
|
||
|
||
- (BOOL)application:(UIApplication *)application continueUserActivity:(NSUserActivity *)userActivity restorationHandler:(void (^)(NSArray<id<UIUserActivityRestoring>> *restorableObjects))restorationHandler {
|
||
[self handleUserActivity:userActivity];
|
||
|
||
return YES;
|
||
}
|
||
|
||
- (void)application:(UIApplication *)application performActionForShortcutItem:(UIApplicationShortcutItem *)shortcutItem completionHandler:(void (^)(BOOL))completionHandler {
|
||
completionHandler([self handleShortcutItem:shortcutItem]);
|
||
}
|
||
|
||
- (BOOL)handleShortcutItem:(UIApplicationShortcutItem *)shortcutItem {
|
||
NSString *type = shortcutItem.type;
|
||
NSString *prefix = [[NSBundle mainBundle].bundleIdentifier stringByAppendingString:@"."];
|
||
BOOL handled = YES;
|
||
|
||
if (!self.activeUsername) {
|
||
handled = NO;
|
||
} else if ([type startsWith:prefix]) {
|
||
type = [type substringFromIndex:[prefix length]];
|
||
if ([type isEqualToString:@"AddFeed"]) {
|
||
[self.navigationController popToRootViewControllerAnimated:NO];
|
||
[self performSelector:@selector(delayedAddSite) withObject:nil afterDelay:0.0];
|
||
} else if ([type isEqualToString:@"AllStories"]) {
|
||
[self.navigationController popToRootViewControllerAnimated:NO];
|
||
[self.feedsViewController didSelectSectionHeaderWithTag:2];
|
||
} else if ([type isEqualToString:@"Search"]) {
|
||
[self.navigationController popToRootViewControllerAnimated:NO];
|
||
[self.feedsViewController didSelectSectionHeaderWithTag:2];
|
||
self.feedDetailViewController.storiesCollection.searchQuery = @"";
|
||
self.feedDetailViewController.storiesCollection.savedSearchQuery = nil;
|
||
self.feedDetailViewController.storiesCollection.inSearch = YES;
|
||
} else {
|
||
handled = NO;
|
||
}
|
||
} else {
|
||
handled = NO;
|
||
}
|
||
|
||
return handled;
|
||
}
|
||
|
||
- (void)delayedAddSite {
|
||
[self.feedsViewController tapAddSite:self];
|
||
}
|
||
|
||
- (void)viewWillAppear:(BOOL)animated {
|
||
[super viewWillAppear:animated];
|
||
|
||
self.title = @"All";
|
||
}
|
||
|
||
- (void)application:(UIApplication *)application
|
||
performFetchWithCompletionHandler:(void (^)(UIBackgroundFetchResult))completionHandler {
|
||
[self createDatabaseConnection];
|
||
[self.feedsViewController fetchFeedList:NO];
|
||
backgroundCompletionHandler = completionHandler;
|
||
}
|
||
|
||
- (void)finishBackground {
|
||
if (!backgroundCompletionHandler) return;
|
||
|
||
NSLog(@"Background fetch complete. Found data: %ld/%ld = %d",
|
||
(long)self.totalUnfetchedStoryCount, (long)self.totalUncachedImagesCount,
|
||
self.totalUnfetchedStoryCount || self.totalUncachedImagesCount);
|
||
if (self.totalUnfetchedStoryCount || self.totalUncachedImagesCount) {
|
||
backgroundCompletionHandler(UIBackgroundFetchResultNewData);
|
||
} else {
|
||
backgroundCompletionHandler(UIBackgroundFetchResultNoData);
|
||
}
|
||
}
|
||
|
||
- (void)registerDefaultsFromSettingsBundle {
|
||
NSString *settingsBundle = [[NSBundle mainBundle] pathForResource:@"Settings" ofType:@"bundle"];
|
||
if(!settingsBundle) {
|
||
NSLog(@"Could not find Settings.bundle");
|
||
return;
|
||
}
|
||
|
||
NSDictionary *settings = [NSDictionary dictionaryWithContentsOfFile:[settingsBundle stringByAppendingPathComponent:@"Root.plist"]];
|
||
NSArray *preferences = [settings objectForKey:@"PreferenceSpecifiers"];
|
||
|
||
NSMutableDictionary *defaultsToRegister = [[NSMutableDictionary alloc] initWithCapacity:[preferences count]];
|
||
for(NSDictionary *prefSpecification in preferences) {
|
||
NSString *key = [prefSpecification objectForKey:@"Key"];
|
||
if (key && [[prefSpecification allKeys] containsObject:@"DefaultValue"]) {
|
||
[defaultsToRegister setObject:[prefSpecification objectForKey:@"DefaultValue"] forKey:key];
|
||
}
|
||
}
|
||
|
||
[[NSUserDefaults standardUserDefaults] registerDefaults:defaultsToRegister];
|
||
|
||
NSString *version = [[[NSBundle mainBundle] infoDictionary] objectForKey:@"CFBundleShortVersionString"];
|
||
[[NSUserDefaults standardUserDefaults] setObject:version forKey:@"version"];
|
||
}
|
||
|
||
- (void)registerForRemoteNotifications {
|
||
UNUserNotificationCenter *center = [UNUserNotificationCenter currentNotificationCenter];
|
||
center.delegate = self;
|
||
[center requestAuthorizationWithOptions:(UNAuthorizationOptionSound | UNAuthorizationOptionAlert | UNAuthorizationOptionBadge) completionHandler:^(BOOL granted, NSError * _Nullable error){
|
||
if(!error){
|
||
dispatch_async(dispatch_get_main_queue(), ^{
|
||
[[UIApplication sharedApplication] registerForRemoteNotifications];
|
||
});
|
||
}
|
||
}];
|
||
|
||
// UNNotificationAction *viewAction = [UNNotificationAction actionWithIdentifier:@"VIEW_STORY_IDENTIFIER"
|
||
// title:@"View story"
|
||
// options:UNNotificationActionOptionForeground];
|
||
UNNotificationAction *readAction = [UNNotificationAction actionWithIdentifier:@"MARK_READ_IDENTIFIER"
|
||
title:@"Mark read"
|
||
options:UNNotificationActionOptionNone];
|
||
UNNotificationAction *starAction = [UNNotificationAction actionWithIdentifier:@"STAR_IDENTIFIER"
|
||
title:@"Save story"
|
||
options:UNNotificationActionOptionNone];
|
||
UNNotificationAction *dismissAction = [UNNotificationAction actionWithIdentifier:@"DISMISS_IDENTIFIER"
|
||
title:@"Dismiss"
|
||
options:UNNotificationActionOptionDestructive];
|
||
UNNotificationCategory *storyCategory = [UNNotificationCategory categoryWithIdentifier:@"STORY_CATEGORY"
|
||
actions:@[readAction, starAction, dismissAction]
|
||
intentIdentifiers:@[]
|
||
options:UNNotificationCategoryOptionNone];
|
||
[center setNotificationCategories:[NSSet setWithObject:storyCategory]];
|
||
}
|
||
|
||
|
||
- (void)registerForBadgeNotifications {
|
||
UNUserNotificationCenter *center = [UNUserNotificationCenter currentNotificationCenter];
|
||
center.delegate = self;
|
||
[center requestAuthorizationWithOptions:(UNAuthorizationOptionBadge) completionHandler:^(BOOL granted, NSError * _Nullable error){
|
||
|
||
}];
|
||
}
|
||
|
||
//Called when a notification is delivered to a foreground app.
|
||
-(void)userNotificationCenter:(UNUserNotificationCenter *)center willPresentNotification:(UNNotification *)notification withCompletionHandler:(void (^)(UNNotificationPresentationOptions options))completionHandler{
|
||
NSLog(@"User Info : %@",notification.request.content.userInfo);
|
||
completionHandler(UNAuthorizationOptionSound | UNAuthorizationOptionAlert | UNAuthorizationOptionBadge);
|
||
}
|
||
|
||
//Called to let your app know which action was selected by the user for a given notification.
|
||
- (void)userNotificationCenter:(UNUserNotificationCenter *)center didReceiveNotificationResponse:(UNNotificationResponse *)response withCompletionHandler:(void (^)(void))completionHandler {
|
||
[self processNotification:response.notification.request.content.userInfo
|
||
action:response.actionIdentifier
|
||
withCompletionHandler:completionHandler];
|
||
}
|
||
|
||
- (void)processNotification:(NSDictionary *)content action:(NSString *)action withCompletionHandler:(void(^)(void))completionHandler {
|
||
NSLog(@"User Info : %@ / %@", content, action);
|
||
NSString *storyHash = [content objectForKey:@"story_hash"];
|
||
NSNumber *storyFeedId = [content objectForKey:@"story_feed_id"];
|
||
NSString *feedIdStr = [NSString stringWithFormat:@"%@", storyFeedId];
|
||
|
||
if (!self.activeUsername) {
|
||
return;
|
||
} else if ([action isEqualToString:@"MARK_READ_IDENTIFIER"]) {
|
||
[self markStoryAsRead:storyHash inFeed:feedIdStr withCallback:^{
|
||
if (completionHandler) completionHandler();
|
||
}];
|
||
} else if ([action isEqualToString:@"STAR_IDENTIFIER"]) {
|
||
[self markStoryAsStarred:storyHash withCallback:^{
|
||
if (completionHandler) completionHandler();
|
||
}];
|
||
} else if ([action isEqualToString:@"VIEW_STORY_IDENTIFIER"] ||
|
||
[action isEqualToString:@"com.apple.UNNotificationDefaultActionIdentifier"]) {
|
||
[self popToRootWithCompletion:^{
|
||
[self loadFeed:feedIdStr withStory:storyHash animated:NO];
|
||
}];
|
||
if (completionHandler) completionHandler();
|
||
} else if ([action isEqualToString:@"DISMISS_IDENTIFIER"]) {
|
||
if (completionHandler) completionHandler();
|
||
}
|
||
|
||
}
|
||
|
||
-(void)application:(UIApplication *)application didRegisterForRemoteNotificationsWithDeviceToken:(NSData *)deviceToken {
|
||
const char *data = [deviceToken bytes];
|
||
NSMutableString *token = [NSMutableString string];
|
||
|
||
for (NSUInteger i = 0; i < [deviceToken length]; i++) {
|
||
[token appendFormat:@"%02.2hhX", data[i]];
|
||
}
|
||
|
||
NSLog(@" -> APNS token: %@", token);
|
||
NSString *url = [NSString stringWithFormat:@"%@/notifications/apns_token/", self.url];
|
||
NSMutableDictionary *params = [NSMutableDictionary dictionary];
|
||
[params setObject:token forKey:@"apns_token"];
|
||
[self POST:url parameters:params success:^(NSURLSessionDataTask * _Nonnull task, id _Nullable responseObject) {
|
||
NSLog(@" -> APNS: %@", responseObject);
|
||
} failure:^(NSURLSessionDataTask * _Nullable task, NSError * _Nonnull error) {
|
||
NSLog(@"Failed to set APNS token");
|
||
}];
|
||
}
|
||
|
||
- (BOOL)application:(UIApplication *)application
|
||
openURL:(NSURL *)url
|
||
sourceApplication:(NSString *)sourceApplication
|
||
annotation:(id)annotation {
|
||
if (self.activeUsername && [url.scheme isEqualToString:@"newsblurwidget"]) {
|
||
NSMutableDictionary *query = [NSMutableDictionary dictionary];
|
||
|
||
for (NSString *component in [url.query componentsSeparatedByString:@"&"]) {
|
||
NSArray *keyAndValue = [component componentsSeparatedByString:@"="];
|
||
|
||
[query setObject:keyAndValue.lastObject forKey:keyAndValue.firstObject];
|
||
}
|
||
|
||
NSString *feedId = query[@"feedId"];
|
||
NSString *storyHash = query[@"storyHash"];
|
||
NSString *error = query[@"error"];
|
||
|
||
if (error.length) {
|
||
[self popToRootWithCompletion:^{
|
||
[self showWidgetSites];
|
||
}];
|
||
|
||
return YES;
|
||
}
|
||
|
||
if (!feedId.length || !storyHash.length) {
|
||
return NO;
|
||
}
|
||
|
||
[self popToRootWithCompletion:^{
|
||
self.inFindingStoryMode = YES;
|
||
[storiesCollection reset];
|
||
storiesCollection.isRiverView = YES;
|
||
|
||
self.tryFeedStoryId = storyHash;
|
||
storiesCollection.activeFolder = @"everything";
|
||
|
||
[self loadRiverFeedDetailView:self.feedDetailViewController withFolder:storiesCollection.activeFolder];
|
||
}];
|
||
|
||
return YES;
|
||
}
|
||
|
||
return NO;
|
||
}
|
||
|
||
- (void)didReceiveMemoryWarning {
|
||
// Releases the view if it doesn't have a superview.
|
||
[super didReceiveMemoryWarning];
|
||
|
||
// Release any cached data, images, etc that aren't in use.
|
||
[cachedStoryImages removeAllObjects];
|
||
}
|
||
|
||
- (void)setupReachability {
|
||
Reachability* reach = [Reachability reachabilityWithHostname:self.host];
|
||
[[NSNotificationCenter defaultCenter] addObserver:self
|
||
selector:@selector(reachabilityChanged:)
|
||
name:kReachabilityChangedNotification
|
||
object:nil];
|
||
reach.reachableBlock = ^(Reachability *reach) {
|
||
NSLog(@"Reachable: %@", reach);
|
||
};
|
||
reach.unreachableBlock = ^(Reachability *reach) {
|
||
NSLog(@"Un-Reachable: %@", reach);
|
||
dispatch_sync(dispatch_get_main_queue(), ^{
|
||
[feedsViewController loadOfflineFeeds:NO];
|
||
});
|
||
};
|
||
[reach startNotifier];
|
||
}
|
||
|
||
- (void)reachabilityChanged:(id)something {
|
||
NSLog(@"Reachability changed: %@", something);
|
||
// Reachability* reach = [Reachability reachabilityWithHostname:self.host];
|
||
|
||
// if (reach.isReachable && feedsViewController.isOffline) {
|
||
// [feedsViewController loadOfflineFeeds:NO];
|
||
//// } else {
|
||
//// [feedsViewController loadOfflineFeeds:NO];
|
||
// }
|
||
}
|
||
|
||
- (NSString *)url {
|
||
if (!self.cachedURL) {
|
||
NSString *url = [[NSUserDefaults standardUserDefaults] objectForKey:@"custom_domain"];
|
||
|
||
if (url.length) {
|
||
if ([url rangeOfString:@"://"].location == NSNotFound) {
|
||
url = [@"http://" stringByAppendingString:url];
|
||
}
|
||
} else {
|
||
url = DEFAULT_NEWSBLUR_URL;
|
||
}
|
||
|
||
self.cachedURL = url;
|
||
}
|
||
|
||
return self.cachedURL;
|
||
}
|
||
|
||
- (NSString *)host {
|
||
NSString *url = self.url;
|
||
NSString *host = nil;
|
||
NSRange range = [url rangeOfString:@"://"];
|
||
|
||
if (url.length && range.location != NSNotFound) {
|
||
host = [url substringFromIndex:range.location + range.length];
|
||
}
|
||
|
||
return host;
|
||
}
|
||
|
||
#pragma mark -
|
||
#pragma mark Social Views
|
||
|
||
- (NSDictionary *)getUser:(NSInteger)userId {
|
||
for (int i = 0; i < storiesCollection.activeFeedUserProfiles.count; i++) {
|
||
if ([[[storiesCollection.activeFeedUserProfiles objectAtIndex:i] objectForKey:@"user_id"] intValue] == userId) {
|
||
return [storiesCollection.activeFeedUserProfiles objectAtIndex:i];
|
||
}
|
||
}
|
||
|
||
// Check DB if not found in active feed
|
||
__block NSDictionary *user;
|
||
[self.database inDatabase:^(FMDatabase *db) {
|
||
NSString *userSql = [NSString stringWithFormat:@"SELECT * FROM users WHERE user_id = %ld", (long)userId];
|
||
FMResultSet *cursor = [db executeQuery:userSql];
|
||
while ([cursor next]) {
|
||
user = [NSJSONSerialization
|
||
JSONObjectWithData:[[cursor stringForColumn:@"user_json"]
|
||
dataUsingEncoding:NSUTF8StringEncoding]
|
||
options:0 error:nil];
|
||
if (user) break;
|
||
}
|
||
[cursor close];
|
||
}];
|
||
|
||
return user;
|
||
}
|
||
|
||
- (void)showUserProfileModal:(id)sender {
|
||
[self hidePopoverAnimated:NO];
|
||
UserProfileViewController *newUserProfile = [[UserProfileViewController alloc] init];
|
||
self.userProfileViewController = newUserProfile;
|
||
UINavigationController *navController = [[UINavigationController alloc] initWithRootViewController:self.userProfileViewController];
|
||
self.userProfileNavigationController = navController;
|
||
self.userProfileNavigationController.navigationBar.translucent = NO;
|
||
|
||
|
||
// adding Done button
|
||
UIBarButtonItem *donebutton = [[UIBarButtonItem alloc]
|
||
initWithTitle:@"Close"
|
||
style:UIBarButtonItemStyleDone
|
||
target:self
|
||
action:@selector(hideUserProfileModal)];
|
||
|
||
newUserProfile.navigationItem.rightBarButtonItem = donebutton;
|
||
newUserProfile.navigationItem.title = self.activeUserProfileName;
|
||
newUserProfile.navigationItem.backBarButtonItem.title = self.activeUserProfileName;
|
||
[newUserProfile getUserProfile];
|
||
if (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad) {
|
||
[self.masterContainerViewController showUserProfilePopover:sender];
|
||
} else {
|
||
[self.navigationController presentViewController:navController animated:YES completion:nil];
|
||
}
|
||
|
||
}
|
||
|
||
- (void)pushUserProfile {
|
||
UserProfileViewController *userProfileView = [[UserProfileViewController alloc] init];
|
||
|
||
|
||
// adding Done button
|
||
UIBarButtonItem *donebutton = [[UIBarButtonItem alloc]
|
||
initWithTitle:@"Close"
|
||
style:UIBarButtonItemStyleDone
|
||
target:self
|
||
action:@selector(hideUserProfileModal)];
|
||
|
||
userProfileView.navigationItem.rightBarButtonItem = donebutton;
|
||
userProfileView.navigationItem.title = self.activeUserProfileName;
|
||
userProfileView.navigationItem.backBarButtonItem.title = self.activeUserProfileName;
|
||
[userProfileView getUserProfile];
|
||
if (self.modalNavigationController.view.window == nil) {
|
||
[self.userProfileNavigationController pushViewController:userProfileView animated:YES];
|
||
} else {
|
||
[self.modalNavigationController pushViewController:userProfileView animated:YES];
|
||
};
|
||
|
||
}
|
||
|
||
- (void)hideUserProfileModal {
|
||
if (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad) {
|
||
[self hidePopover];
|
||
} else {
|
||
[self.navigationController dismissViewControllerAnimated:YES completion:nil];
|
||
}
|
||
}
|
||
|
||
- (void)resizePreviewSize {
|
||
[feedsViewController resizePreviewSize];
|
||
}
|
||
|
||
- (void)resizeFontSize {
|
||
[feedsViewController resizeFontSize];
|
||
}
|
||
|
||
- (void)popToRootWithCompletion:(void (^)(void))completion {
|
||
if (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad) {
|
||
if (completion) {
|
||
[CATransaction begin];
|
||
[CATransaction setCompletionBlock:completion];
|
||
}
|
||
|
||
[masterContainerViewController dismissViewControllerAnimated:NO completion:nil];
|
||
[self.navigationController popToViewController:[self.navigationController.viewControllers objectAtIndex:0] animated:YES];
|
||
|
||
if (completion) {
|
||
[CATransaction commit];
|
||
}
|
||
} else {
|
||
[self.navigationController popToRootViewControllerAnimated:NO];
|
||
|
||
if (completion) {
|
||
completion();
|
||
}
|
||
}
|
||
}
|
||
|
||
- (void)showPremiumDialog {
|
||
UINavigationController *navController = self.navigationController;
|
||
if (self.premiumNavigationController == nil) {
|
||
self.premiumNavigationController = [[UINavigationController alloc]
|
||
initWithRootViewController:self.premiumViewController];
|
||
}
|
||
self.premiumNavigationController.navigationBar.translucent = NO;
|
||
|
||
if (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad) {
|
||
[masterContainerViewController dismissViewControllerAnimated:NO completion:nil];
|
||
premiumNavigationController.modalPresentationStyle = UIModalPresentationFormSheet;
|
||
[masterContainerViewController presentViewController:premiumNavigationController animated:YES completion:nil];
|
||
[self.premiumViewController.view setNeedsLayout];
|
||
} else {
|
||
[navController presentViewController:self.premiumNavigationController animated:YES completion:nil];
|
||
}
|
||
}
|
||
|
||
- (void)showPreferences {
|
||
if (!preferencesViewController) {
|
||
preferencesViewController = [[IASKAppSettingsViewController alloc] init];
|
||
[[ThemeManager themeManager] addThemeGestureRecognizerToView:self.preferencesViewController.view];
|
||
}
|
||
|
||
[self hidePopover];
|
||
|
||
preferencesViewController.delegate = self.feedsViewController;
|
||
preferencesViewController.showDoneButton = YES;
|
||
preferencesViewController.showCreditsFooter = NO;
|
||
preferencesViewController.title = @"Preferences";
|
||
|
||
[self setHiddenPreferencesAnimated:NO];
|
||
|
||
[[NSUserDefaults standardUserDefaults] setObject:@"Delete offline stories..."
|
||
forKey:@"offline_cache_empty_stories"];
|
||
|
||
UINavigationController *navController = [[UINavigationController alloc] initWithRootViewController:preferencesViewController];
|
||
self.modalNavigationController = navController;
|
||
self.modalNavigationController.navigationBar.translucent = NO;
|
||
|
||
if (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad) {
|
||
[masterContainerViewController dismissViewControllerAnimated:NO completion:nil];
|
||
self.modalNavigationController.modalPresentationStyle = UIModalPresentationFormSheet;
|
||
[masterContainerViewController presentViewController:modalNavigationController animated:YES completion:nil];
|
||
} else {
|
||
[navigationController presentViewController:modalNavigationController animated:YES completion:nil];
|
||
}
|
||
}
|
||
|
||
- (void)setHiddenPreferencesAnimated:(BOOL)animated {
|
||
NSMutableSet *hiddenSet = [NSMutableSet set];
|
||
|
||
BOOL offline_enabled = [[NSUserDefaults standardUserDefaults] boolForKey:@"offline_allowed"];
|
||
if (!offline_enabled) {
|
||
[hiddenSet addObjectsFromArray:@[@"offline_image_download",
|
||
@"offline_download_connection",
|
||
@"offline_store_limit"]];
|
||
}
|
||
BOOL system_font_enabled = [[NSUserDefaults standardUserDefaults] boolForKey:@"use_system_font_size"];
|
||
if (system_font_enabled) {
|
||
[hiddenSet addObjectsFromArray:@[@"feed_list_font_size"]];
|
||
}
|
||
if (@available(iOS 13.0, *)) {
|
||
BOOL theme_follow_system = [[NSUserDefaults standardUserDefaults] boolForKey:@"theme_follow_system"];
|
||
if (theme_follow_system) {
|
||
[hiddenSet addObjectsFromArray:@[@"theme_auto_toggle", @"theme_auto_brightness", @"theme_style", @"theme_gesture"]];
|
||
[[ThemeManager themeManager] updateForSystemAppearance];
|
||
}
|
||
}
|
||
BOOL theme_auto_toggle = [[NSUserDefaults standardUserDefaults] boolForKey:@"theme_auto_toggle"];
|
||
if (theme_auto_toggle) {
|
||
[hiddenSet addObjectsFromArray:@[@"theme_style", @"theme_gesture"]];
|
||
} else {
|
||
[hiddenSet addObjectsFromArray:@[@"theme_auto_brightness"]];
|
||
}
|
||
|
||
BOOL story_full_screen = [[NSUserDefaults standardUserDefaults] boolForKey:@"story_full_screen"];
|
||
if (!story_full_screen) {
|
||
[hiddenSet addObjectsFromArray:@[@"story_hide_status_bar"]];
|
||
}
|
||
|
||
[preferencesViewController setHiddenKeys:hiddenSet animated:animated];
|
||
}
|
||
|
||
- (void)showFeedChooserForOperation:(FeedChooserOperation)operation {
|
||
[self hidePopover];
|
||
|
||
self.feedChooserViewController = [FeedChooserViewController new];
|
||
self.feedChooserViewController.operation = operation;
|
||
|
||
UINavigationController *nav = [[UINavigationController alloc] initWithRootViewController:self.feedChooserViewController];
|
||
|
||
self.modalNavigationController = nav;
|
||
self.modalNavigationController.navigationBar.translucent = NO;
|
||
|
||
if (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad) {
|
||
self.modalNavigationController.modalPresentationStyle = UIModalPresentationFormSheet;
|
||
[masterContainerViewController presentViewController:modalNavigationController animated:YES completion:nil];
|
||
} else {
|
||
[navigationController presentViewController:modalNavigationController animated:YES completion:nil];
|
||
}
|
||
}
|
||
|
||
- (void)showMuteSites {
|
||
[self showFeedChooserForOperation:FeedChooserOperationMuteSites];
|
||
}
|
||
|
||
- (void)showOrganizeSites {
|
||
[self showFeedChooserForOperation:FeedChooserOperationOrganizeSites];
|
||
}
|
||
|
||
- (void)showWidgetSites {
|
||
[self showFeedChooserForOperation:FeedChooserOperationWidgetSites];
|
||
}
|
||
|
||
- (void)showFindFriends {
|
||
[self hidePopover];
|
||
|
||
FriendsListViewController *friendsBVC = [[FriendsListViewController alloc] init];
|
||
UINavigationController *friendsNav = [[UINavigationController alloc] initWithRootViewController:friendsListViewController];
|
||
|
||
self.friendsListViewController = friendsBVC;
|
||
self.modalNavigationController = friendsNav;
|
||
self.modalNavigationController.navigationBar.translucent = NO;
|
||
|
||
if (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad) {
|
||
[masterContainerViewController dismissViewControllerAnimated:NO completion:nil];
|
||
self.modalNavigationController.modalPresentationStyle = UIModalPresentationFormSheet;
|
||
[masterContainerViewController presentViewController:modalNavigationController animated:YES completion:nil];
|
||
} else {
|
||
[navigationController presentViewController:modalNavigationController animated:YES completion:nil];
|
||
}
|
||
[self.friendsListViewController loadSuggestedFriendsList];
|
||
}
|
||
|
||
- (void)showSendTo:(UIViewController *)vc sender:(id)sender {
|
||
NSString *authorName = [activeStory objectForKey:@"story_authors"];
|
||
NSString *text = [activeStory objectForKey:@"story_content"];
|
||
NSString *title = [[activeStory objectForKey:@"story_title"] stringByDecodingHTMLEntities];
|
||
NSArray *images = [activeStory objectForKey:@"image_urls"];
|
||
NSURL *url = [NSURL URLWithString:[activeStory objectForKey:@"story_permalink"]];
|
||
NSString *feedId = [NSString stringWithFormat:@"%@", [activeStory objectForKey:@"story_feed_id"]];
|
||
NSDictionary *feed = [self getFeed:feedId];
|
||
NSString *feedTitle = [feed objectForKey:@"feed_title"];
|
||
|
||
if ([activeStory objectForKey:@"original_text"]) {
|
||
text = [activeStory objectForKey:@"original_text"];
|
||
}
|
||
|
||
return [self showSendTo:vc
|
||
sender:sender
|
||
withUrl:url
|
||
authorName:authorName
|
||
text:text
|
||
title:title
|
||
feedTitle:feedTitle
|
||
images:images];
|
||
}
|
||
|
||
- (void)showSendTo:(UIViewController *)vc sender:(id)sender
|
||
withUrl:(NSURL *)url
|
||
authorName:(NSString *)authorName
|
||
text:(NSString *)text
|
||
title:(NSString *)title
|
||
feedTitle:(NSString *)feedTitle
|
||
images:(NSArray *)images {
|
||
|
||
// iOS 8+
|
||
if (text) {
|
||
NSString *maybeFeedTitle = feedTitle ? [NSString stringWithFormat:@" via %@", feedTitle] : @"";
|
||
text = [NSString stringWithFormat:@"<html><body><br><br><hr style=\"border: none; overflow: hidden; height: 1px;width: 100%%;background-color: #C0C0C0;\"><br><a href=\"%@\">%@</a>%@<br>%@</body></html>", [url absoluteString], title, maybeFeedTitle, text];
|
||
}
|
||
|
||
NBActivityItemSource *activityItemSource = [[NBActivityItemSource alloc] initWithUrl:url authorName:authorName text:text title:title feedTitle:feedTitle];
|
||
NSArray *activityItems = @[activityItemSource, url];
|
||
|
||
NSMutableArray *appActivities = [[NSMutableArray alloc] init];
|
||
if (url) [appActivities addObject:[[TUSafariActivity alloc] init]];
|
||
if (url) [appActivities addObject:[[ARChromeActivity alloc]
|
||
initWithCallbackURL:[NSURL URLWithString:@"newsblur://"]]];
|
||
if (url) [appActivities addObject:[[NBCopyLinkActivity alloc] init]];
|
||
|
||
UIActivityViewController *activityViewController = [[UIActivityViewController alloc]
|
||
initWithActivityItems:activityItems
|
||
applicationActivities:appActivities];
|
||
[activityViewController setTitle:title];
|
||
[activityViewController setCompletionWithItemsHandler:^(NSString *activityType, BOOL completed, NSArray *returnedItems, NSError *activityError) {
|
||
self.isPresentingActivities = NO;
|
||
|
||
NSString *_completedString;
|
||
NSLog(@"activityType: %@", activityType);
|
||
if (!activityType) return;
|
||
|
||
if ([activityType isEqualToString:UIActivityTypePostToTwitter]) {
|
||
_completedString = @"Posted";
|
||
} else if ([activityType isEqualToString:UIActivityTypePostToFacebook]) {
|
||
_completedString = @"Posted";
|
||
} else if ([activityType isEqualToString:UIActivityTypeMail]) {
|
||
_completedString = @"Sent";
|
||
} else if ([activityType isEqualToString:UIActivityTypeMessage]) {
|
||
_completedString = @"Sent";
|
||
} else if ([activityType isEqualToString:UIActivityTypeCopyToPasteboard]) {
|
||
_completedString = @"Copied";
|
||
} else if ([activityType isEqualToString:UIActivityTypeAirDrop]) {
|
||
_completedString = @"Airdropped";
|
||
} else if ([activityType isEqualToString:@"com.ideashower.ReadItLaterPro.AddToPocketExtension"]) {
|
||
return;
|
||
} else if ([activityType isEqualToString:@"TUSafariActivity"]) {
|
||
return;
|
||
} else if ([activityType isEqualToString:@"ARChromeActivity"]) {
|
||
return;
|
||
} else if ([activityType isEqualToString:@"NBCopyLinkActivity"]) {
|
||
_completedString = @"Copied Link";
|
||
} else {
|
||
_completedString = @"Saved";
|
||
}
|
||
[MBProgressHUD hideHUDForView:vc.view animated:NO];
|
||
if (completed) {
|
||
MBProgressHUD *storyHUD = [MBProgressHUD showHUDAddedTo:vc.view animated:YES];
|
||
storyHUD.customView = [[UIImageView alloc] initWithImage:[UIImage imageNamed:@"37x-Checkmark.png"]];
|
||
storyHUD.mode = MBProgressHUDModeCustomView;
|
||
storyHUD.removeFromSuperViewOnHide = YES;
|
||
storyHUD.labelText = _completedString;
|
||
[storyHUD hide:YES afterDelay:1];
|
||
}
|
||
}];
|
||
|
||
if (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad) {
|
||
BOOL fromPopover = [self hidePopoverAnimated:NO];
|
||
[self.masterContainerViewController presentViewController:activityViewController animated:!fromPopover completion:nil];
|
||
activityViewController.modalPresentationStyle = UIModalPresentationPopover;
|
||
// iOS 8+
|
||
UIPopoverPresentationController *popPC = activityViewController.popoverPresentationController;
|
||
popPC.permittedArrowDirections = UIPopoverArrowDirectionAny;
|
||
popPC.backgroundColor = UIColorFromLightDarkRGB(NEWSBLUR_WHITE_COLOR, 0x707070);
|
||
|
||
if ([sender isKindOfClass:[UIBarButtonItem class]]) {
|
||
popPC.barButtonItem = sender;
|
||
} else if ([sender isKindOfClass:[NSValue class]]) {
|
||
// // Uncomment below to show share popover from linked text. Problem is
|
||
// // that on finger up the link will open.
|
||
CGPoint pt = [(NSValue *)sender CGPointValue];
|
||
CGRect rect = CGRectMake(pt.x, pt.y, 1, 1);
|
||
//// [[OSKPresentationManager sharedInstance] presentActivitySheetForContent:content presentingViewController:vc popoverFromRect:rect inView:self.storyPageControl.view permittedArrowDirections:UIPopoverArrowDirectionAny animated:YES options:options];
|
||
|
||
// [[OSKPresentationManager sharedInstance] presentActivitySheetForContent:content
|
||
// presentingViewController:vc options:options];
|
||
popPC.sourceRect = rect;
|
||
popPC.sourceView = self.storyPageControl.view;
|
||
} else {
|
||
popPC.sourceRect = [sender frame];
|
||
popPC.sourceView = [sender superview];
|
||
|
||
// [[OSKPresentationManager sharedInstance] presentActivitySheetForContent:content presentingViewController:vc popoverFromRect:[sender frame] inView:[sender superview] permittedArrowDirections:UIPopoverArrowDirectionAny animated:YES options:options];
|
||
}
|
||
} else {
|
||
[self.navigationController presentViewController:activityViewController animated:YES completion:^{}];
|
||
}
|
||
self.isPresentingActivities = YES;
|
||
}
|
||
|
||
- (void)showShareView:(NSString *)type
|
||
setUserId:(NSString *)userId
|
||
setUsername:(NSString *)username
|
||
setReplyId:(NSString *)replyId {
|
||
|
||
[self.shareViewController setCommentType:type];
|
||
if (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad) {
|
||
[self.masterContainerViewController transitionToShareView];
|
||
[self.shareViewController setSiteInfo:type setUserId:userId setUsername:username setReplyId:replyId];
|
||
} else {
|
||
if (self.shareNavigationController == nil) {
|
||
UINavigationController *shareNav = [[UINavigationController alloc]
|
||
initWithRootViewController:self.shareViewController];
|
||
self.shareNavigationController = shareNav;
|
||
self.shareNavigationController.navigationBar.translucent = NO;
|
||
}
|
||
[self.navigationController presentViewController:self.shareNavigationController animated:YES completion:^{
|
||
[self.shareViewController setSiteInfo:type setUserId:userId setUsername:username setReplyId:replyId];
|
||
}];
|
||
}
|
||
}
|
||
|
||
- (void)hideShareView:(BOOL)resetComment {
|
||
if (resetComment) {
|
||
self.shareViewController.commentField.text = @"";
|
||
self.shareViewController.currentType = nil;
|
||
}
|
||
|
||
if (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad) {
|
||
[self.masterContainerViewController transitionFromShareView];
|
||
[self.storyPageControl becomeFirstResponder];
|
||
} else if (!self.showingSafariViewController) {
|
||
[self.navigationController dismissViewControllerAnimated:YES completion:nil];
|
||
[self.shareViewController.commentField resignFirstResponder];
|
||
}
|
||
}
|
||
|
||
- (void)resetShareComments {
|
||
[shareViewController clearComments];
|
||
}
|
||
|
||
#pragma mark -
|
||
#pragma mark View Management
|
||
|
||
- (void)showLogin {
|
||
self.dictFeeds = nil;
|
||
self.dictSocialFeeds = nil;
|
||
self.dictSavedStoryTags = nil;
|
||
self.dictSavedStoryFeedCounts = nil;
|
||
self.dictFolders = nil;
|
||
self.dictFoldersArray = nil;
|
||
self.notificationFeedIds = nil;
|
||
self.userActivitiesArray = nil;
|
||
self.userInteractionsArray = nil;
|
||
self.dictUnreadCounts = nil;
|
||
self.dictTextFeeds = nil;
|
||
|
||
[self.feedsViewController.feedTitlesTable reloadData];
|
||
[self.feedsViewController resetToolbar];
|
||
|
||
[self.dashboardViewController.interactionsModule.interactionsTable reloadData];
|
||
[self.dashboardViewController.activitiesModule.activitiesTable reloadData];
|
||
|
||
NSUserDefaults *userPreferences = [NSUserDefaults standardUserDefaults];
|
||
[userPreferences setInteger:-1 forKey:@"selectedIntelligence"];
|
||
[userPreferences synchronize];
|
||
|
||
if (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad) {
|
||
if (self.masterContainerViewController.presentedViewController == loginViewController) {
|
||
NSLog(@"Already showing login!");
|
||
return;
|
||
}
|
||
loginViewController.modalPresentationStyle = UIModalPresentationFullScreen;
|
||
[self.masterContainerViewController presentViewController:loginViewController animated:NO completion:nil];
|
||
} else {
|
||
[feedsMenuViewController dismissViewControllerAnimated:NO completion:nil];
|
||
if (navigationController.isViewLoaded && navigationController.view.window) {
|
||
if ([self.navigationController visibleViewController] == loginViewController) {
|
||
NSLog(@"Already showing login!");
|
||
return;
|
||
}
|
||
[self.navigationController presentViewController:loginViewController animated:NO completion:nil];
|
||
}
|
||
}
|
||
}
|
||
|
||
- (void)showFirstTimeUser {
|
||
// [self.feedsViewController changeToAllMode];
|
||
|
||
UINavigationController *ftux = [[UINavigationController alloc] initWithRootViewController:self.firstTimeUserViewController];
|
||
|
||
self.ftuxNavigationController = ftux;
|
||
self.ftuxNavigationController.navigationBar.translucent = NO;
|
||
|
||
if (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad) {
|
||
[masterContainerViewController dismissViewControllerAnimated:NO completion:nil];
|
||
self.ftuxNavigationController.modalPresentationStyle = UIModalPresentationFullScreen;
|
||
[self.masterContainerViewController presentViewController:self.ftuxNavigationController animated:YES completion:nil];
|
||
|
||
self.ftuxNavigationController.view.superview.frame = CGRectMake(0, 0, 540, 540);//it's important to do this after
|
||
UIInterfaceOrientation orientation = [UIApplication sharedApplication].statusBarOrientation;
|
||
if (UIInterfaceOrientationIsPortrait(orientation)) {
|
||
self.ftuxNavigationController.view.superview.center = self.view.center;
|
||
} else {
|
||
self.ftuxNavigationController.view.superview.center = CGPointMake(self.view.center.y, self.view.center.x);
|
||
}
|
||
|
||
} else {
|
||
[self.navigationController presentViewController:self.ftuxNavigationController animated:YES completion:nil];
|
||
}
|
||
}
|
||
|
||
- (void)showMoveSite {
|
||
UINavigationController *navController = self.navigationController;
|
||
|
||
if (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad) {
|
||
[masterContainerViewController dismissViewControllerAnimated:NO completion:nil];
|
||
moveSiteViewController.modalPresentationStyle=UIModalPresentationFormSheet;
|
||
[navController presentViewController:moveSiteViewController animated:YES completion:nil];
|
||
} else {
|
||
[self hidePopover];
|
||
[navController presentViewController:moveSiteViewController animated:YES completion:nil];
|
||
}
|
||
}
|
||
|
||
- (void)openTrainSite {
|
||
[self hidePopover];
|
||
// Needs a delay because the menu will close the popover.
|
||
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 0.01 * NSEC_PER_SEC),
|
||
dispatch_get_main_queue(), ^{
|
||
[self
|
||
openTrainSiteWithFeedLoaded:YES
|
||
from:self.feedDetailViewController.settingsBarButton];
|
||
});
|
||
}
|
||
|
||
- (void)openTrainSiteWithFeedLoaded:(BOOL)feedLoaded from:(id)sender {
|
||
UINavigationController *navController = self.navigationController;
|
||
trainerViewController.feedTrainer = YES;
|
||
trainerViewController.storyTrainer = NO;
|
||
trainerViewController.feedLoaded = feedLoaded;
|
||
|
||
if (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad) {
|
||
// trainerViewController.modalPresentationStyle=UIModalPresentationFormSheet;
|
||
// [navController presentViewController:trainerViewController animated:YES completion:nil];
|
||
[self.masterContainerViewController showTrainingPopover:sender];
|
||
} else {
|
||
if (self.trainNavigationController == nil) {
|
||
self.trainNavigationController = [[UINavigationController alloc]
|
||
initWithRootViewController:self.trainerViewController];
|
||
}
|
||
self.trainNavigationController.navigationBar.translucent = NO;
|
||
[navController presentViewController:self.trainNavigationController animated:YES completion:nil];
|
||
}
|
||
}
|
||
|
||
- (void)openTrainStory:(id)sender {
|
||
UINavigationController *navController = self.navigationController;
|
||
trainerViewController.feedTrainer = NO;
|
||
trainerViewController.storyTrainer = YES;
|
||
trainerViewController.feedLoaded = YES;
|
||
if (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad) {
|
||
[self.masterContainerViewController showTrainingPopover:sender];
|
||
} else {
|
||
if (self.trainNavigationController == nil) {
|
||
self.trainNavigationController = [[UINavigationController alloc]
|
||
initWithRootViewController:self.trainerViewController];
|
||
}
|
||
self.trainNavigationController.navigationBar.translucent = NO;
|
||
[navController presentViewController:self.trainNavigationController animated:YES completion:nil];
|
||
}
|
||
}
|
||
|
||
- (void)openNotificationsWithFeed:(NSString *)feedId {
|
||
[self hidePopover];
|
||
// Needs a delay because the menu will close the popover.
|
||
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 0.01 * NSEC_PER_SEC), dispatch_get_main_queue(), ^{
|
||
[self openNotificationsWithFeed:feedId sender:self.feedDetailViewController.settingsBarButton];
|
||
});
|
||
}
|
||
|
||
- (void)openNotificationsWithFeed:(NSString *)feedId sender:(id)sender {
|
||
UINavigationController *navController = self.navigationController;
|
||
|
||
if (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad) {
|
||
[self.masterContainerViewController showNotificationsPopoverWithFeed:feedId sender:sender];
|
||
} else {
|
||
if (self.notificationsNavigationController == nil) {
|
||
self.notificationsNavigationController = [[UINavigationController alloc]
|
||
initWithRootViewController:self.notificationsViewController];
|
||
}
|
||
self.notificationsNavigationController.navigationBar.translucent = NO;
|
||
self.notificationsViewController.feedId = feedId;
|
||
[navController presentViewController:self.notificationsNavigationController animated:YES completion:nil];
|
||
}
|
||
}
|
||
|
||
- (void)updateNotifications:(NSDictionary *)params feed:(NSString *)feedId {
|
||
NSString *urlString = [NSString stringWithFormat:@"%@/notifications/feed/",
|
||
self.url];
|
||
NSMutableDictionary *feed = [[self.dictFeeds objectForKey:feedId] mutableCopy];
|
||
|
||
[feed setObject:params[@"notification_types"] forKey:@"notification_types"];
|
||
[feed setObject:params[@"notification_filter"] forKey:@"notification_filter"];
|
||
|
||
[self.dictFeeds setObject:feed forKey:feedId];
|
||
|
||
[self POST:urlString parameters:params success:^(NSURLSessionDataTask * _Nonnull task, id _Nullable responseObject) {
|
||
NSLog(@"Saved notifications %@: %@", feedId, params);
|
||
[self checkForFeedNotifications];
|
||
} failure:^(NSURLSessionDataTask * _Nullable task, NSError * _Nonnull error) {
|
||
NSLog(@"Failed to save notifications: %@", params);
|
||
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *)task.response;
|
||
[self.notificationsViewController informError:error statusCode:httpResponse.statusCode];
|
||
}];
|
||
}
|
||
|
||
- (void)checkForFeedNotifications {
|
||
NSMutableArray *foundNotificationFeedIds = [NSMutableArray array];
|
||
|
||
for (NSDictionary *feed in self.dictFeeds.allValues) {
|
||
if (![feed isKindOfClass:[NSDictionary class]]) {
|
||
continue;
|
||
}
|
||
|
||
NSArray *types = [feed objectForKey:@"notification_types"];
|
||
if (types) {
|
||
for (NSString *notificationType in types) {
|
||
if ([notificationType isEqualToString:@"ios"]) {
|
||
[self registerForRemoteNotifications];
|
||
}
|
||
}
|
||
if ([types count]) {
|
||
[foundNotificationFeedIds addObject:[feed objectForKey:@"id"]];
|
||
}
|
||
}
|
||
}
|
||
|
||
self.notificationFeedIds = [foundNotificationFeedIds sortedArrayUsingComparator:^NSComparisonResult(id _Nonnull obj1, id _Nonnull obj2) {
|
||
NSString *feed1Title = [[[self.dictFeeds objectForKey:[NSString stringWithFormat:@"%@", obj1]] objectForKey:@"feed_title"] lowercaseString];
|
||
NSString *feed2Title = [[[self.dictFeeds objectForKey:[NSString stringWithFormat:@"%@", obj2]] objectForKey:@"feed_title"] lowercaseString];
|
||
|
||
return [feed1Title compare:feed2Title];
|
||
}];
|
||
}
|
||
|
||
- (void)openStatisticsWithFeed:(NSString *)feedId sender:(id)sender {
|
||
feedId = [self feedIdWithoutSearchQuery:feedId];
|
||
NSString *urlString = [NSString stringWithFormat:@"%@/rss_feeds/statistics_embedded/%@", self.url, feedId];
|
||
NSURL *url = [NSURL URLWithString:urlString];
|
||
NSDictionary *feed = self.dictFeeds[feedId];
|
||
NSString *title = feed[@"feed_title"];
|
||
|
||
[self showInAppBrowser:url withCustomTitle:title fromSender:sender];
|
||
}
|
||
|
||
- (void)openUserTagsStory:(id)sender {
|
||
if (!self.userTagsViewController) {
|
||
self.userTagsViewController = [[UserTagsViewController alloc] init];
|
||
}
|
||
|
||
[self.userTagsViewController view]; // Force viewDidLoad
|
||
CGRect frame = [sender CGRectValue];
|
||
[self showPopoverWithViewController:self.userTagsViewController contentSize:CGSizeMake(220, 382) sourceView:self.storyPageControl.view sourceRect:frame];
|
||
}
|
||
|
||
#pragma mark - UIPopoverPresentationControllerDelegate
|
||
|
||
- (UIModalPresentationStyle)adaptivePresentationStyleForPresentationController:(UIPresentationController *)controller {
|
||
return UIModalPresentationNone;
|
||
}
|
||
|
||
- (void)popoverPresentationControllerDidDismissPopover:(UIPopoverPresentationController *)popoverPresentationController {
|
||
[self.navigationController.topViewController becomeFirstResponder];
|
||
}
|
||
|
||
#pragma mark - Network
|
||
|
||
- (void)cancelRequests {
|
||
[self clearNetworkManager];
|
||
}
|
||
|
||
- (void)clearNetworkManager {
|
||
for (NSString *networkOperationIdentifier in self.networkBackgroundTasks) {
|
||
[self endNetworkOperation:networkOperationIdentifier];
|
||
}
|
||
|
||
self.networkBackgroundTasks = [NSMutableDictionary new];
|
||
|
||
[networkManager invalidateSessionCancelingTasks:YES];
|
||
networkManager = [AFHTTPSessionManager manager];
|
||
networkManager.responseSerializer = [AFJSONResponseSerializer serializer];
|
||
[networkManager.requestSerializer setCachePolicy:NSURLRequestReloadIgnoringLocalCacheData];
|
||
|
||
NSString *currentiPhoneVersion = [[[NSBundle mainBundle] infoDictionary]
|
||
objectForKey:@"CFBundleVersion"];
|
||
NSString *UA;
|
||
if (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad) {
|
||
UA = [NSString stringWithFormat:@"NewsBlur iPad App v%@", currentiPhoneVersion];
|
||
} else {
|
||
UA = [NSString stringWithFormat:@"NewsBlur iPhone App v%@", currentiPhoneVersion];
|
||
}
|
||
[networkManager.requestSerializer setValue:UA forHTTPHeaderField:@"User-Agent"];
|
||
}
|
||
|
||
- (NSString *)beginNetworkOperation {
|
||
NSString *networkOperationIdentifier = [NSUUID UUID].UUIDString;
|
||
|
||
UIBackgroundTaskIdentifier backgroundTaskIdentifier = [[UIApplication sharedApplication] beginBackgroundTaskWithExpirationHandler:^{
|
||
[self endNetworkOperation:networkOperationIdentifier];
|
||
}];
|
||
|
||
if (backgroundTaskIdentifier != UIBackgroundTaskInvalid) {
|
||
self.networkBackgroundTasks[networkOperationIdentifier] = @(backgroundTaskIdentifier);
|
||
}
|
||
|
||
return networkOperationIdentifier;
|
||
}
|
||
|
||
- (void)endNetworkOperation:(NSString *)networkOperationIdentifier {
|
||
UIBackgroundTaskIdentifier identifier = self.networkBackgroundTasks[networkOperationIdentifier].integerValue;
|
||
|
||
if (identifier != UIBackgroundTaskInvalid) {
|
||
[[UIApplication sharedApplication] endBackgroundTask:identifier];
|
||
}
|
||
|
||
[self.networkBackgroundTasks removeObjectForKey:networkOperationIdentifier];
|
||
}
|
||
|
||
- (void)safelyInvokeTarget:(id _Nonnull)target withSelector:(SEL _Nullable)selector passingObject:(id _Nullable)object {
|
||
if (selector == NULL) {
|
||
return;
|
||
}
|
||
|
||
IMP imp = [target methodForSelector:selector];
|
||
void (*func)(id, SEL, id _Nullable) = (void *)imp;
|
||
func(target, selector, object);
|
||
}
|
||
|
||
- (void)GET:(NSString *)urlString
|
||
parameters:(id)parameters
|
||
success:(void (^)(NSURLSessionDataTask * _Nonnull, id _Nullable))success
|
||
failure:(void (^)(NSURLSessionDataTask * _Nullable, NSError * _Nonnull))failure {
|
||
NSString *networkOperationIdentifier = [self beginNetworkOperation];
|
||
|
||
[networkManager GET:urlString parameters:parameters progress:nil success:^(NSURLSessionDataTask * _Nonnull task, id _Nullable responseObject) {
|
||
if (success) {
|
||
success(task, responseObject);
|
||
}
|
||
|
||
[self endNetworkOperation:networkOperationIdentifier];
|
||
} failure:^(NSURLSessionDataTask * _Nullable task, NSError * _Nonnull error) {
|
||
if (failure) {
|
||
failure(task, error);
|
||
}
|
||
|
||
[self endNetworkOperation:networkOperationIdentifier];
|
||
}];
|
||
}
|
||
|
||
- (void)GET:(NSString *)urlString
|
||
parameters:(id)parameters
|
||
target:(id)target
|
||
success:(SEL)success
|
||
failure:(SEL)failure {
|
||
[self GET:urlString parameters:parameters success:^(NSURLSessionDataTask * _Nonnull task, id _Nullable responseObject) {
|
||
[self safelyInvokeTarget:target withSelector:success passingObject:responseObject];
|
||
} failure:^(NSURLSessionDataTask * _Nullable task, NSError * _Nonnull error) {
|
||
[self safelyInvokeTarget:target withSelector:failure passingObject:error];
|
||
}];
|
||
}
|
||
|
||
- (void)POST:(NSString *)urlString
|
||
parameters:(id)parameters
|
||
success:(void (^)(NSURLSessionDataTask * _Nonnull, id _Nullable))success
|
||
failure:(void (^)(NSURLSessionDataTask * _Nullable, NSError * _Nonnull))failure {
|
||
NSString *networkOperationIdentifier = [self beginNetworkOperation];
|
||
|
||
[networkManager POST:urlString parameters:parameters progress:nil success:^(NSURLSessionDataTask * _Nonnull task, id _Nullable responseObject) {
|
||
if (success) {
|
||
success(task, responseObject);
|
||
}
|
||
|
||
[self endNetworkOperation:networkOperationIdentifier];
|
||
} failure:^(NSURLSessionDataTask * _Nullable task, NSError * _Nonnull error) {
|
||
if (failure) {
|
||
failure(task, error);
|
||
}
|
||
|
||
[self endNetworkOperation:networkOperationIdentifier];
|
||
}];
|
||
}
|
||
|
||
- (void)POST:(NSString *)urlString
|
||
parameters:(id)parameters
|
||
target:(id)target
|
||
success:(SEL)success
|
||
failure:(SEL)failure {
|
||
[self POST:urlString parameters:parameters success:^(NSURLSessionDataTask * _Nonnull task, id _Nullable responseObject) {
|
||
[self safelyInvokeTarget:target withSelector:success passingObject:responseObject];
|
||
} failure:^(NSURLSessionDataTask * _Nullable task, NSError * _Nonnull error) {
|
||
[self safelyInvokeTarget:target withSelector:failure passingObject:error];
|
||
}];
|
||
}
|
||
|
||
- (NSHTTPCookie *)sessionIdCookie {
|
||
NSURL *url = [NSURL URLWithString:self.url];
|
||
NSArray *cookies = [[NSHTTPCookieStorage sharedHTTPCookieStorage] cookiesForURL: url];
|
||
|
||
for (NSHTTPCookie *cookie in cookies) {
|
||
if ([cookie.name isEqualToString:@"newsblur_sessionid"]) {
|
||
return cookie;
|
||
}
|
||
}
|
||
|
||
return nil;
|
||
}
|
||
|
||
- (void)prepareWebView:(WKWebView *)webView completionHandler:(void (^)(void))completion {
|
||
NSHTTPCookie *cookie = self.sessionIdCookie;
|
||
|
||
if (cookie != nil) {
|
||
[webView.configuration.websiteDataStore.httpCookieStore setCookie:cookie completionHandler:completion];
|
||
} else {
|
||
completion();
|
||
}
|
||
}
|
||
|
||
#pragma mark -
|
||
|
||
- (void)loadFolder:(NSString *)folder feedID:(NSString *)feedIdStr {
|
||
feedIdStr = [self feedIdWithoutSearchQuery:feedIdStr];
|
||
NSDictionary *feed;
|
||
storiesCollection.isReadView = NO;
|
||
if ([self isSocialFeed:feedIdStr]) {
|
||
feed = [dictSocialFeeds objectForKey:feedIdStr];
|
||
storiesCollection.isSocialView = YES;
|
||
storiesCollection.isSavedView = NO;
|
||
} else if ([self isSavedFeed:feedIdStr]) {
|
||
feed = [dictSavedStoryTags objectForKey:feedIdStr];
|
||
storiesCollection.isSocialView = NO;
|
||
storiesCollection.isSavedView = YES;
|
||
storiesCollection.activeSavedStoryTag = [feed objectForKey:@"tag"];
|
||
} else {
|
||
feed = [dictFeeds objectForKey:feedIdStr];
|
||
storiesCollection.isSocialView = NO;
|
||
storiesCollection.isSavedView = NO;
|
||
}
|
||
|
||
[storiesCollection setActiveFeed:feed];
|
||
[storiesCollection setActiveFolder:folder];
|
||
readStories = [NSMutableArray array];
|
||
[folderCountCache removeObjectForKey:folder];
|
||
storiesCollection.activeClassifiers = [NSMutableDictionary dictionary];
|
||
|
||
[self loadFeedDetailView];
|
||
}
|
||
|
||
- (void)reloadFeedsView:(BOOL)showLoader {
|
||
[feedsViewController fetchFeedList:showLoader];
|
||
}
|
||
|
||
- (void)loadFeedDetailView {
|
||
[self loadFeedDetailView:YES];
|
||
}
|
||
|
||
- (void)loadFeedDetailView:(BOOL)transition {
|
||
self.inFeedDetail = YES;
|
||
popoverHasFeedView = YES;
|
||
|
||
[feedDetailViewController resetFeedDetail];
|
||
if (feedDetailViewController == dashboardViewController.storiesModule) {
|
||
feedDetailViewController.storiesCollection = dashboardViewController.storiesModule.storiesCollection;
|
||
} else {
|
||
feedDetailViewController.storiesCollection = storiesCollection;
|
||
}
|
||
|
||
if (transition) {
|
||
UIBarButtonItem *newBackButton = [[UIBarButtonItem alloc]
|
||
initWithTitle: @"All"
|
||
style: UIBarButtonItemStylePlain
|
||
target: nil
|
||
action: nil];
|
||
[feedsViewController.navigationItem setBackBarButtonItem:newBackButton];
|
||
|
||
if (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad) {
|
||
[self.masterContainerViewController transitionToFeedDetail];
|
||
} else {
|
||
[navigationController pushViewController:feedDetailViewController
|
||
animated:YES];
|
||
}
|
||
}
|
||
|
||
[self flushQueuedReadStories:NO withCallback:^{
|
||
[self flushQueuedSavedStories:NO withCallback:^{
|
||
dispatch_async(dispatch_get_main_queue(), ^{
|
||
[feedDetailViewController fetchFeedDetail:1 withCallback:nil];
|
||
});
|
||
}];
|
||
}];
|
||
}
|
||
|
||
- (void)loadFeed:(NSString *)feedId
|
||
withStory:(NSString *)contentId
|
||
animated:(BOOL)animated {
|
||
NSDictionary *feed = [self getFeed:feedId];
|
||
NSLog(@"loadFeed: %@", feed);
|
||
|
||
if (!feed || [feed isKindOfClass:[NSNull class]]) {
|
||
if (self.tryFeedFeedId) {
|
||
self.tryFeedStoryId = nil;
|
||
self.tryFeedFeedId = nil;
|
||
} else {
|
||
self.tryFeedFeedId = feedId;
|
||
self.tryFeedStoryId = contentId;
|
||
}
|
||
return;
|
||
}
|
||
|
||
self.isTryFeedView = YES;
|
||
self.inFindingStoryMode = YES;
|
||
self.tryFeedStoryId = contentId;
|
||
self.tryFeedFeedId = nil;
|
||
storiesCollection.isSocialView = NO;
|
||
storiesCollection.activeFeed = feed;
|
||
storiesCollection.activeFolder = nil;
|
||
|
||
if (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad) {
|
||
[self loadFeedDetailView];
|
||
} else if (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPhone) {
|
||
[self.navigationController popToRootViewControllerAnimated:NO];
|
||
[self hidePopoverAnimated:NO completion:^{
|
||
if (self.navigationController.presentedViewController) {
|
||
[self.navigationController dismissViewControllerAnimated:NO completion:^{
|
||
[self loadFeedDetailView];
|
||
}];
|
||
} else {
|
||
[self loadFeedDetailView];
|
||
}
|
||
}];
|
||
}
|
||
}
|
||
|
||
- (void)loadTryFeedDetailView:(NSString *)feedId
|
||
withStory:(NSString *)contentId
|
||
isSocial:(BOOL)social
|
||
withUser:(NSDictionary *)user
|
||
showFindingStory:(BOOL)showHUD {
|
||
NSDictionary *feed = [self getFeed:feedId];
|
||
|
||
if (social) {
|
||
storiesCollection.isSocialView = YES;
|
||
self.inFindingStoryMode = YES;
|
||
|
||
if (feed == nil) {
|
||
feed = user;
|
||
self.isTryFeedView = YES;
|
||
}
|
||
} else {
|
||
if (feed == nil) {
|
||
feed = user;
|
||
self.isTryFeedView = YES;
|
||
|
||
}
|
||
storiesCollection.isSocialView = NO;
|
||
// [self setInFindingStoryMode:NO];
|
||
}
|
||
|
||
self.tryFeedStoryId = contentId;
|
||
storiesCollection.activeFeed = feed;
|
||
storiesCollection.activeFolder = nil;
|
||
|
||
if (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad) {
|
||
[self loadFeedDetailView];
|
||
} else if (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPhone) {
|
||
[self.navigationController popToRootViewControllerAnimated:NO];
|
||
[self hidePopoverAnimated:YES completion:^{
|
||
if (self.navigationController.presentedViewController) {
|
||
[self.navigationController dismissViewControllerAnimated:YES completion:^{
|
||
[self loadFeedDetailView];
|
||
}];
|
||
} else {
|
||
[self loadFeedDetailView];
|
||
}
|
||
}];
|
||
}
|
||
}
|
||
|
||
- (void)loadStarredDetailViewWithStory:(NSString *)contentId
|
||
showFindingStory:(BOOL)showHUD {
|
||
if (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPhone) {
|
||
[self.navigationController popToRootViewControllerAnimated:NO];
|
||
[self.navigationController dismissViewControllerAnimated:YES completion:nil];
|
||
[self hidePopoverAnimated:NO];
|
||
}
|
||
|
||
self.inFindingStoryMode = YES;
|
||
[storiesCollection reset];
|
||
storiesCollection.isRiverView = YES;
|
||
|
||
self.tryFeedStoryId = contentId;
|
||
storiesCollection.activeFolder = @"saved_stories";
|
||
|
||
[self loadRiverFeedDetailView:feedDetailViewController withFolder:@"saved_stories"];
|
||
|
||
if (showHUD) {
|
||
if (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad) {
|
||
[self.storyPageControl showShareHUD:@"Finding story..."];
|
||
} else {
|
||
MBProgressHUD *HUD = [MBProgressHUD showHUDAddedTo:self.feedDetailViewController.view animated:YES];
|
||
HUD.labelText = @"Finding story...";
|
||
}
|
||
}
|
||
}
|
||
|
||
- (BOOL)isSocialFeed:(NSString *)feedIdStr {
|
||
if ([feedIdStr length] > 6) {
|
||
NSString *feedIdSubStr = [feedIdStr substringToIndex:6];
|
||
if ([feedIdSubStr isEqualToString:@"social"]) {
|
||
return YES;
|
||
}
|
||
}
|
||
return NO;
|
||
}
|
||
|
||
- (BOOL)isSavedSearch:(NSString *)feedIdStr {
|
||
return [feedIdStr containsString:@"?"];
|
||
}
|
||
|
||
- (BOOL)isSavedFeed:(NSString *)feedIdStr {
|
||
return [feedIdStr startsWith:@"saved:"];
|
||
}
|
||
|
||
- (NSInteger)savedStoriesCountForFeed:(NSString *)feedIdStr {
|
||
return [self.dictSavedStoryFeedCounts[feedIdStr] integerValue];
|
||
}
|
||
|
||
- (BOOL)isSavedStoriesIntelligenceMode {
|
||
return self.selectedIntelligence == 2;
|
||
}
|
||
|
||
- (NSArray *)allFeedIds {
|
||
NSMutableArray *mutableFeedIds = [NSMutableArray array];
|
||
|
||
for (NSString *folderName in self.dictFoldersArray) {
|
||
for (id feedId in self.dictFolders[folderName]) {
|
||
if (![feedId isKindOfClass:[NSString class]] || ![self isSavedFeed:feedId]) {
|
||
[mutableFeedIds addObject:feedId];
|
||
}
|
||
}
|
||
}
|
||
|
||
return mutableFeedIds;
|
||
}
|
||
|
||
- (NSArray *)feedIdsForFolderTitle:(NSString *)folderTitle {
|
||
if ([folderTitle isEqualToString:@"everything"] || [folderTitle isEqualToString:@"infrequent"]) {
|
||
return @[folderTitle];
|
||
} else {
|
||
return self.dictFolders[folderTitle];
|
||
}
|
||
}
|
||
|
||
- (BOOL)isPortrait {
|
||
UIInterfaceOrientation orientation = [UIApplication sharedApplication].statusBarOrientation;
|
||
if (orientation == UIInterfaceOrientationPortrait || orientation == UIInterfaceOrientationPortraitUpsideDown) {
|
||
return YES;
|
||
} else {
|
||
return NO;
|
||
}
|
||
}
|
||
|
||
- (BOOL)isCompactWidth {
|
||
return self.compactWidth > 0.0;
|
||
}
|
||
|
||
- (void)confirmLogout {
|
||
UIAlertController *alertController = [UIAlertController alertControllerWithTitle:@"Positive?" message:nil preferredStyle:UIAlertControllerStyleAlert];
|
||
[alertController addAction:[UIAlertAction actionWithTitle: @"Logout" style:UIAlertActionStyleDefault handler:^(UIAlertAction * action) {
|
||
[alertController dismissViewControllerAnimated:YES completion:nil];
|
||
NSLog(@"Logging out...");
|
||
NSString *urlString = [NSString stringWithFormat:@"%@/reader/logout?api=1",
|
||
self.url];
|
||
[self GET:urlString parameters:nil success:^(NSURLSessionDataTask * _Nonnull task, id _Nullable responseObject) {
|
||
[MBProgressHUD hideHUDForView:self.view animated:YES];
|
||
[self showLogin];
|
||
} failure:^(NSURLSessionDataTask * _Nullable task, NSError * _Nonnull error) {
|
||
[MBProgressHUD hideHUDForView:self.view animated:YES];
|
||
}];
|
||
|
||
[MBProgressHUD hideHUDForView:self.view animated:YES];
|
||
MBProgressHUD *HUD = [MBProgressHUD showHUDAddedTo:self.view animated:YES];
|
||
HUD.labelText = @"Logging out...";
|
||
}]];
|
||
[alertController addAction:[UIAlertAction actionWithTitle:@"Cancel"
|
||
style:UIAlertActionStyleCancel handler:nil]];
|
||
[self.feedsViewController presentViewController:alertController animated:YES completion:nil];
|
||
}
|
||
|
||
- (void)showConnectToService:(NSString *)serviceName {
|
||
AuthorizeServicesViewController *serviceVC = [[AuthorizeServicesViewController alloc] init];
|
||
serviceVC.url = [NSString stringWithFormat:@"/oauth/%@_connect", serviceName];
|
||
serviceVC.type = serviceName;
|
||
serviceVC.fromStory = YES;
|
||
if (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad) {
|
||
UINavigationController *connectNav = [[UINavigationController alloc]
|
||
initWithRootViewController:serviceVC];
|
||
self.modalNavigationController = connectNav;
|
||
[masterContainerViewController dismissViewControllerAnimated:NO completion:nil];
|
||
self.modalNavigationController.modalPresentationStyle = UIModalPresentationFormSheet;
|
||
self.modalNavigationController.navigationBar.translucent = NO;
|
||
[self.masterContainerViewController presentViewController:modalNavigationController
|
||
animated:YES completion:nil];
|
||
} else {
|
||
[self.shareNavigationController pushViewController:serviceVC animated:YES];
|
||
}
|
||
}
|
||
|
||
- (void)showAlert:(UIAlertController *)alert withViewController:(UIViewController *)vc {
|
||
if (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad) {
|
||
[self.masterContainerViewController presentViewController:alert animated:YES completion:nil];
|
||
} else {
|
||
[vc presentViewController:alert animated:YES completion:nil];
|
||
}
|
||
}
|
||
|
||
- (void)refreshUserProfile:(void(^)(void))callback {
|
||
NSString *urlString = [NSString stringWithFormat:@"%@/social/load_user_profile",
|
||
self.url];
|
||
[self GET:urlString parameters:nil success:^(NSURLSessionDataTask * _Nonnull task, id _Nullable responseObject) {
|
||
self.dictUserProfile = [responseObject objectForKey:@"user_profile"];
|
||
self.dictSocialServices = [responseObject objectForKey:@"services"];
|
||
callback();
|
||
} failure:^(NSURLSessionDataTask * _Nullable task, NSError * _Nonnull error) {
|
||
NSLog(@"Failed user profile");
|
||
callback();
|
||
}];
|
||
}
|
||
|
||
- (void)refreshFeedCount:(id)feedId {
|
||
// [feedsViewController fadeFeed:feedId];
|
||
[feedsViewController redrawFeedCounts:feedId];
|
||
[feedsViewController refreshHeaderCounts];
|
||
}
|
||
|
||
- (void)loadRiverFeedDetailView:(FeedDetailViewController *)feedDetailView withFolder:(NSString *)folder {
|
||
self.readStories = [NSMutableArray array];
|
||
NSMutableArray *feeds = [NSMutableArray array];
|
||
BOOL transferFromDashboard = [folder isEqualToString:@"river_dashboard"];
|
||
|
||
self.inFeedDetail = YES;
|
||
[feedDetailView resetFeedDetail];
|
||
if (feedDetailView == dashboardViewController.storiesModule) {
|
||
feedDetailView.storiesCollection = dashboardViewController.storiesModule.storiesCollection;
|
||
} else if (feedDetailView == feedDetailViewController) {
|
||
feedDetailView.storiesCollection = storiesCollection;
|
||
}
|
||
|
||
[feedDetailView.storiesCollection reset];
|
||
|
||
if (transferFromDashboard) {
|
||
StoriesCollection *dashboardCollection = dashboardViewController.storiesModule.storiesCollection;
|
||
[feedDetailView.storiesCollection transferStoriesFromCollection:dashboardCollection];
|
||
feedDetailView.storiesCollection.isRiverView = YES;
|
||
feedDetailView.storiesCollection.transferredFromDashboard = YES;
|
||
[feedDetailView.storiesCollection setActiveFolder:@"everything"];
|
||
} else {
|
||
if ([folder isEqualToString:@"river_global"]) {
|
||
feedDetailView.storiesCollection.isSocialRiverView = YES;
|
||
feedDetailView.storiesCollection.isRiverView = YES;
|
||
[feedDetailView.storiesCollection setActiveFolder:@"river_global"];
|
||
} else if ([folder isEqualToString:@"river_blurblogs"]) {
|
||
feedDetailView.storiesCollection.isSocialRiverView = YES;
|
||
feedDetailView.storiesCollection.isRiverView = YES;
|
||
// add all the feeds from every NON blurblog folder
|
||
[feedDetailView.storiesCollection setActiveFolder:@"river_blurblogs"];
|
||
for (NSString *folderName in self.feedsViewController.activeFeedLocations) {
|
||
if ([folderName isEqualToString:@"river_blurblogs"]) { // remove all blurblugs which is a blank folder name
|
||
NSArray *originalFolder = [self.dictFolders objectForKey:folderName];
|
||
NSArray *folderFeeds = [self.feedsViewController.activeFeedLocations objectForKey:folderName];
|
||
for (int l=0; l < [folderFeeds count]; l++) {
|
||
[feeds addObject:[originalFolder objectAtIndex:[[folderFeeds objectAtIndex:l] intValue]]];
|
||
}
|
||
}
|
||
}
|
||
} else if ([folder isEqualToString:@"everything"] || [folder isEqualToString:@"infrequent"]) {
|
||
feedDetailView.storiesCollection.isRiverView = YES;
|
||
// add all the feeds from every NON blurblog folder
|
||
[feedDetailView.storiesCollection setActiveFolder:folder];
|
||
for (NSString *folderName in self.feedsViewController.activeFeedLocations) {
|
||
if ([folderName isEqualToString:@"river_blurblogs"]) continue;
|
||
if ([folderName isEqualToString:@"read_stories"]) continue;
|
||
if ([folderName isEqualToString:@"saved_searches"]) continue;
|
||
if ([folderName isEqualToString:@"saved_stories"]) continue;
|
||
NSArray *originalFolder = [self.dictFolders objectForKey:folderName];
|
||
NSArray *folderFeeds = [self.feedsViewController.activeFeedLocations objectForKey:folderName];
|
||
for (int l=0; l < [folderFeeds count]; l++) {
|
||
[feeds addObject:[originalFolder objectAtIndex:[[folderFeeds objectAtIndex:l] intValue]]];
|
||
}
|
||
}
|
||
[self.folderCountCache removeAllObjects];
|
||
} else {
|
||
feedDetailView.storiesCollection.isRiverView = YES;
|
||
NSString *folderName = [self.dictFoldersArray objectAtIndex:[folder intValue]];
|
||
|
||
if ([folder isEqualToString:@"saved_stories"] || [folderName isEqualToString:@"saved_stories"]) {
|
||
feedDetailView.storiesCollection.isSavedView = YES;
|
||
[feedDetailView.storiesCollection setActiveFolder:@"saved_stories"];
|
||
} else if ([folder isEqualToString:@"saved_searches"] || [folderName isEqualToString:@"saved_searches"]) {
|
||
feedDetailView.storiesCollection.isSavedView = YES;
|
||
[feedDetailView.storiesCollection setActiveFolder:@"saved_searches"];
|
||
} else if ([folder isEqualToString:@"read_stories"] || [folderName isEqualToString:@"read_stories"]) {
|
||
feedDetailView.storiesCollection.isReadView = YES;
|
||
[feedDetailView.storiesCollection setActiveFolder:@"read_stories"];
|
||
} else {
|
||
[feedDetailView.storiesCollection setActiveFolder:folderName];
|
||
}
|
||
NSArray *originalFolder = [self.dictFolders objectForKey:folderName];
|
||
NSArray *activeFeedLocations = [self.feedsViewController.activeFeedLocations objectForKey:folderName];
|
||
for (int l=0; l < [activeFeedLocations count]; l++) {
|
||
[feeds addObject:[originalFolder objectAtIndex:[[activeFeedLocations objectAtIndex:l] intValue]]];
|
||
}
|
||
|
||
}
|
||
feedDetailView.storiesCollection.activeFolderFeeds = feeds;
|
||
NSUserDefaults *preferences = [NSUserDefaults standardUserDefaults];
|
||
if (!self.feedsViewController.viewShowingAllFeeds &&
|
||
[preferences boolForKey:@"show_feeds_after_being_read"]) {
|
||
for (id feedId in feeds) {
|
||
NSString *feedIdStr = [NSString stringWithFormat:@"%@", feedId];
|
||
[self.feedsViewController.stillVisibleFeeds setObject:[NSNumber numberWithBool:YES] forKey:feedIdStr];
|
||
}
|
||
}
|
||
}
|
||
|
||
if (feedDetailView.storiesCollection.activeFolder) {
|
||
[self.folderCountCache removeObjectForKey:feedDetailView.storiesCollection.activeFolder];
|
||
}
|
||
|
||
if (feedDetailView == feedDetailViewController && feedDetailView.navigationController == nil) {
|
||
UIBarButtonItem *newBackButton = [[UIBarButtonItem alloc] initWithTitle: @"All"
|
||
style: UIBarButtonItemStylePlain
|
||
target: nil
|
||
action: nil];
|
||
[feedsViewController.navigationItem setBackBarButtonItem: newBackButton];
|
||
if (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad) {
|
||
[self.masterContainerViewController transitionToFeedDetail];
|
||
} else {
|
||
UINavigationController *navController = self.navigationController;
|
||
[navController pushViewController:feedDetailViewController animated:YES];
|
||
}
|
||
}
|
||
|
||
if (!transferFromDashboard) {
|
||
[self flushQueuedReadStories:NO withCallback:^{
|
||
[self flushQueuedSavedStories:NO withCallback:^{
|
||
dispatch_async(dispatch_get_main_queue(), ^{
|
||
[feedDetailView fetchRiver];
|
||
});
|
||
}];
|
||
}];
|
||
} else {
|
||
[feedDetailView reloadData];
|
||
}
|
||
}
|
||
|
||
- (void)openDashboardRiverForStory:(NSString *)contentId
|
||
showFindingStory:(BOOL)showHUD {
|
||
if (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPhone) {
|
||
[self.navigationController popToRootViewControllerAnimated:NO];
|
||
[self.navigationController dismissViewControllerAnimated:YES completion:nil];
|
||
[self hidePopoverAnimated:NO];
|
||
}
|
||
|
||
self.inFindingStoryMode = YES;
|
||
[storiesCollection reset];
|
||
storiesCollection.isRiverView = YES;
|
||
|
||
self.tryFeedStoryId = contentId;
|
||
storiesCollection.activeFolder = @"everything";
|
||
|
||
[self loadRiverFeedDetailView:feedDetailViewController withFolder:@"river_dashboard"];
|
||
|
||
if (showHUD) {
|
||
if (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad) {
|
||
[self.storyPageControl showShareHUD:@"Finding story..."];
|
||
} else {
|
||
MBProgressHUD *HUD = [MBProgressHUD showHUDAddedTo:self.feedDetailViewController.view animated:YES];
|
||
HUD.labelText = @"Finding story...";
|
||
}
|
||
}
|
||
}
|
||
|
||
- (void)adjustStoryDetailWebView {
|
||
// change the web view
|
||
[storyPageControl.currentPage changeWebViewWidth];
|
||
[storyPageControl.nextPage changeWebViewWidth];
|
||
[storyPageControl.previousPage changeWebViewWidth];
|
||
}
|
||
|
||
- (void)calibrateStoryTitles {
|
||
[self.feedDetailViewController checkScroll];
|
||
[self.feedDetailViewController changeActiveFeedDetailRow];
|
||
|
||
}
|
||
|
||
- (void)recalculateIntelligenceScores:(id)feedId {
|
||
NSString *feedIdStr = [NSString stringWithFormat:@"%@", feedId];
|
||
NSMutableArray *newFeedStories = [NSMutableArray array];
|
||
|
||
for (NSDictionary *story in storiesCollection.activeFeedStories) {
|
||
NSString *storyFeedId = [NSString stringWithFormat:@"%@",
|
||
[story objectForKey:@"story_feed_id"]];
|
||
if (![storyFeedId isEqualToString:feedIdStr]) {
|
||
[newFeedStories addObject:story];
|
||
continue;
|
||
}
|
||
|
||
NSMutableDictionary *newStory = [story mutableCopy];
|
||
|
||
// If the story is visible, mark it as sticky so it doesn't go away on page loads.
|
||
NSInteger score = [NewsBlurAppDelegate computeStoryScore:[story objectForKey:@"intelligence"]];
|
||
if (score >= self.selectedIntelligence) {
|
||
[newStory setObject:[NSNumber numberWithBool:YES] forKey:@"sticky"];
|
||
}
|
||
|
||
NSNumber *zero = [NSNumber numberWithInt:0];
|
||
NSMutableDictionary *intelligence = [NSMutableDictionary
|
||
dictionaryWithObjects:[NSArray arrayWithObjects:
|
||
[zero copy], [zero copy],
|
||
[zero copy], [zero copy], nil]
|
||
forKeys:[NSArray arrayWithObjects:
|
||
@"author", @"feed", @"tags", @"title", nil]];
|
||
NSDictionary *classifiers = [storiesCollection.activeClassifiers objectForKey:feedIdStr];
|
||
|
||
for (NSString *title in [classifiers objectForKey:@"titles"]) {
|
||
if ([[intelligence objectForKey:@"title"] intValue] <= 0 &&
|
||
[[story objectForKey:@"story_title"] containsString:title]) {
|
||
int score = [[[classifiers objectForKey:@"titles"] objectForKey:title] intValue];
|
||
[intelligence setObject:[NSNumber numberWithInt:score] forKey:@"title"];
|
||
}
|
||
}
|
||
|
||
for (NSString *author in [classifiers objectForKey:@"authors"]) {
|
||
if ([[intelligence objectForKey:@"author"] intValue] <= 0 &&
|
||
[[story objectForKey:@"story_authors"] class] != [NSNull class] &&
|
||
[[story objectForKey:@"story_authors"] containsString:author]) {
|
||
int score = [[[classifiers objectForKey:@"authors"] objectForKey:author] intValue];
|
||
[intelligence setObject:[NSNumber numberWithInt:score] forKey:@"author"];
|
||
}
|
||
}
|
||
|
||
for (NSString *tag in [classifiers objectForKey:@"tags"]) {
|
||
if ([[intelligence objectForKey:@"tags"] intValue] <= 0 &&
|
||
[[story objectForKey:@"story_tags"] class] != [NSNull class] &&
|
||
[[story objectForKey:@"story_tags"] containsObject:tag]) {
|
||
int score = [[[classifiers objectForKey:@"tags"] objectForKey:tag] intValue];
|
||
[intelligence setObject:[NSNumber numberWithInt:score] forKey:@"tags"];
|
||
}
|
||
}
|
||
|
||
for (NSString *feed in [classifiers objectForKey:@"feeds"]) {
|
||
if ([[intelligence objectForKey:@"feed"] intValue] <= 0 &&
|
||
[storyFeedId isEqualToString:feed]) {
|
||
int score = [[[classifiers objectForKey:@"feeds"] objectForKey:feed] intValue];
|
||
[intelligence setObject:[NSNumber numberWithInt:score] forKey:@"feed"];
|
||
}
|
||
}
|
||
|
||
[newStory setObject:intelligence forKey:@"intelligence"];
|
||
[newFeedStories addObject:newStory];
|
||
}
|
||
|
||
storiesCollection.activeFeedStories = newFeedStories;
|
||
}
|
||
|
||
- (void)changeActiveFeedDetailRow {
|
||
[feedDetailViewController changeActiveFeedDetailRow];
|
||
}
|
||
|
||
- (void)loadStoryDetailView {
|
||
if (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPhone || self.isCompactWidth) {
|
||
[navigationController pushViewController:storyPageControl animated:YES];
|
||
navigationController.navigationItem.hidesBackButton = YES;
|
||
}
|
||
|
||
NSInteger activeStoryLocation = [storiesCollection locationOfActiveStory];
|
||
if (activeStoryLocation >= 0) {
|
||
BOOL animated = (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad &&
|
||
!self.tryFeedCategory);
|
||
[self.storyPageControl view];
|
||
[self.storyPageControl.view setNeedsLayout];
|
||
[self.storyPageControl.view layoutIfNeeded];
|
||
|
||
NSDictionary *params = @{@"location" : @(activeStoryLocation), @"animated" : @(animated)};
|
||
|
||
if (self.isCompactWidth) {
|
||
[self performSelector:@selector(deferredChangePage:) withObject:params afterDelay:0.0];
|
||
} else {
|
||
[self deferredChangePage:params];
|
||
}
|
||
}
|
||
|
||
[MBProgressHUD hideHUDForView:self.storyPageControl.view animated:YES];
|
||
}
|
||
|
||
- (void)deferredChangePage:(NSDictionary *)params {
|
||
[self.storyPageControl changePage:[params[@"location"] integerValue] animated:[params[@"animated"] boolValue]];
|
||
[self.storyPageControl animateIntoPlace:YES];
|
||
}
|
||
|
||
- (void)setTitle:(NSString *)title {
|
||
UILabel *label = [[UILabel alloc] init];
|
||
[label setFont:[UIFont boldSystemFontOfSize:16.0]];
|
||
[label setBackgroundColor:[UIColor clearColor]];
|
||
[label setTextColor:UIColorFromRGB(0x404040)];
|
||
[label setText:title];
|
||
[label setShadowOffset:CGSizeMake(0, -1)];
|
||
[label setShadowColor:UIColorFromRGB(0xFAFAFA)];
|
||
[label sizeToFit];
|
||
[navigationController.navigationBar.topItem setTitleView:label];
|
||
}
|
||
|
||
- (void)showOriginalStory:(NSURL *)url {
|
||
NSUserDefaults *preferences = [NSUserDefaults standardUserDefaults];
|
||
|
||
if (!url) {
|
||
UIAlertController* alert = [UIAlertController alertControllerWithTitle:@"Nowhere to go"
|
||
message:@"The story doesn't link anywhere."
|
||
preferredStyle:UIAlertControllerStyleAlert];
|
||
|
||
UIAlertAction* defaultAction = [UIAlertAction actionWithTitle:@"Oh well" style:UIAlertActionStyleDefault
|
||
handler:^(UIAlertAction * action) {}];
|
||
|
||
[alert addAction:defaultAction];
|
||
[navigationController presentViewController:alert animated:YES completion:nil];
|
||
return;
|
||
}
|
||
|
||
NSString *storyBrowser = [preferences stringForKey:@"story_browser"];
|
||
if ([storyBrowser isEqualToString:@"safari"]) {
|
||
[[UIApplication sharedApplication] openURL:url options:@{} completionHandler:nil];
|
||
// [[UIApplication sharedApplication] openURL:url];
|
||
return;
|
||
} else if ([storyBrowser isEqualToString:@"chrome"] &&
|
||
[[UIApplication sharedApplication] canOpenURL:[NSURL URLWithString:@"googlechrome-x-callback://"]]) {
|
||
NSString *openingURL = [url.absoluteString stringByAddingPercentEncodingWithAllowedCharacters:[NSCharacterSet URLHostAllowedCharacterSet]];
|
||
NSURL *callbackURL = [NSURL URLWithString:@"newsblur://"];
|
||
NSString *callback = [callbackURL.absoluteString stringByAddingPercentEncodingWithAllowedCharacters:[NSCharacterSet URLHostAllowedCharacterSet]];
|
||
NSString *sourceName = [[[NSBundle mainBundle]objectForInfoDictionaryKey:@"CFBundleName"] stringByAddingPercentEncodingWithAllowedCharacters:[NSCharacterSet URLHostAllowedCharacterSet]];
|
||
|
||
NSURL *activityURL = [NSURL URLWithString:
|
||
[NSString stringWithFormat:@"googlechrome-x-callback://x-callback-url/open/?url=%@&x-success=%@&x-source=%@",
|
||
openingURL,
|
||
callback,
|
||
sourceName]];
|
||
|
||
[[UIApplication sharedApplication] openURL:activityURL options:@{} completionHandler:nil];
|
||
return;
|
||
} else if ([storyBrowser isEqualToString:@"opera_mini"] &&
|
||
[[UIApplication sharedApplication] canOpenURL:[NSURL URLWithString:@"opera-http://"]]) {
|
||
|
||
|
||
NSString *operaURL;
|
||
NSRange prefix = [[url absoluteString] rangeOfString: @"http"];
|
||
if (NSNotFound != prefix.location) {
|
||
operaURL = [[url absoluteString]
|
||
stringByReplacingCharactersInRange: prefix
|
||
withString: @"opera-http"];
|
||
}
|
||
|
||
[[UIApplication sharedApplication] openURL:[NSURL URLWithString:operaURL] options:@{} completionHandler:nil];
|
||
return;
|
||
} else if ([storyBrowser isEqualToString:@"firefox"]) {
|
||
NSString *encodedURL = [url.absoluteString stringByAddingPercentEncodingWithAllowedCharacters:[NSCharacterSet URLHostAllowedCharacterSet]];
|
||
NSString *firefoxURL = [NSString stringWithFormat:@"%@%@", @"firefox://open-url?url=", encodedURL];
|
||
[[UIApplication sharedApplication] openURL:[NSURL URLWithString:firefoxURL] options:@{} completionHandler:nil];
|
||
} else if ([storyBrowser isEqualToString:@"edge"]){
|
||
NSString *edgeURL;
|
||
NSRange prefix = [[url absoluteString] rangeOfString: @"http"];
|
||
|
||
if (NSNotFound != prefix.location) {
|
||
edgeURL = [[url absoluteString]
|
||
stringByReplacingCharactersInRange: prefix
|
||
withString: @"microsoft-edge-http"];
|
||
}
|
||
|
||
[[UIApplication sharedApplication] openURL:[NSURL URLWithString:edgeURL] options:@{} completionHandler:nil];
|
||
} else if ([storyBrowser isEqualToString:@"brave"]){
|
||
NSString *encodedURL = [url.absoluteString stringByAddingPercentEncodingWithAllowedCharacters:[NSCharacterSet URLHostAllowedCharacterSet]];
|
||
NSString *braveURL = [NSString stringWithFormat:@"%@%@", @"brave://open-url?url=", encodedURL];
|
||
[[UIApplication sharedApplication] openURL:[NSURL URLWithString:braveURL] options:@{} completionHandler:nil];
|
||
} else if ([storyBrowser isEqualToString:@"inappsafari"]) {
|
||
[self showSafariViewControllerWithURL:url useReader:NO];
|
||
} else if ([storyBrowser isEqualToString:@"inappsafarireader"]) {
|
||
[self showSafariViewControllerWithURL:url useReader:YES];
|
||
} else {
|
||
[self showInAppBrowser:url withCustomTitle:nil fromSender:nil];
|
||
}
|
||
}
|
||
|
||
- (void)showInAppBrowser:(NSURL *)url withCustomTitle:(NSString *)customTitle fromSender:(id)sender {
|
||
if (!originalStoryViewController) {
|
||
originalStoryViewController = [[OriginalStoryViewController alloc] init];
|
||
}
|
||
|
||
self.activeOriginalStoryURL = url;
|
||
originalStoryViewController.customPageTitle = customTitle;
|
||
|
||
if (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad) {
|
||
if ([sender isKindOfClass:[UIBarButtonItem class]]) {
|
||
[originalStoryViewController view]; // Force viewDidLoad
|
||
[originalStoryViewController loadInitialStory];
|
||
[self showPopoverWithViewController:originalStoryViewController contentSize:CGSizeMake(600.0, 1000.0) barButtonItem:sender];
|
||
} else if ([sender isKindOfClass:[UITableViewCell class]]) {
|
||
UITableViewCell *cell = (UITableViewCell *)sender;
|
||
|
||
[originalStoryViewController view]; // Force viewDidLoad
|
||
[originalStoryViewController loadInitialStory];
|
||
[self showPopoverWithViewController:originalStoryViewController contentSize:CGSizeMake(600.0, 1000.0) sourceView:cell sourceRect:cell.bounds];
|
||
} else {
|
||
[self.masterContainerViewController transitionToOriginalView];
|
||
}
|
||
} else {
|
||
if ([[navigationController viewControllers]
|
||
containsObject:originalStoryViewController]) {
|
||
return;
|
||
}
|
||
[navigationController pushViewController:originalStoryViewController
|
||
animated:YES];
|
||
[originalStoryViewController view]; // Force viewDidLoad
|
||
[originalStoryViewController loadInitialStory];
|
||
}
|
||
}
|
||
|
||
- (void)showSafariViewControllerWithURL:(NSURL *)url useReader:(BOOL)useReader {
|
||
SFSafariViewControllerConfiguration *config = [SFSafariViewControllerConfiguration new];
|
||
config.entersReaderIfAvailable = useReader;
|
||
self.safariViewController = [[SFSafariViewController alloc] initWithURL:url configuration:config];
|
||
self.safariViewController.delegate = self;
|
||
[self.storyPageControl setNavigationBarHidden:NO];
|
||
[navigationController presentViewController:self.safariViewController animated:YES completion:nil];
|
||
}
|
||
|
||
- (BOOL)showingSafariViewController {
|
||
return self.safariViewController.delegate != nil;
|
||
}
|
||
|
||
- (void)safariViewControllerDidFinish:(SFSafariViewController *)controller {
|
||
// You'd think doing this in the dismiss completion block would work... but nope.
|
||
[self performSelector:@selector(deferredSafariCleanup) withObject:nil afterDelay:0.2];
|
||
controller.delegate = nil;
|
||
[controller dismissViewControllerAnimated:YES completion:nil];
|
||
}
|
||
|
||
- (void)deferredSafariCleanup {
|
||
// if (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad) {
|
||
// self.navigationController.view.frame = CGRectMake(self.navigationController.view.frame.origin.x, self.navigationController.view.frame.origin.y, self.isPortrait ? 270.0 : 370.0, self.navigationController.view.frame.size.height);
|
||
// }
|
||
|
||
[self.storyPageControl reorientPages];
|
||
}
|
||
|
||
- (void)navigationController:(UINavigationController *)_navigationController willShowViewController:(UIViewController *)viewController animated:(BOOL)animated {
|
||
if ([viewController isKindOfClass:[SFSafariViewController class]] || [viewController isKindOfClass:[FontSettingsViewController class]]) {
|
||
[_navigationController setNavigationBarHidden:YES animated:YES];
|
||
} else {
|
||
[_navigationController setNavigationBarHidden:NO animated:YES];
|
||
}
|
||
}
|
||
|
||
- (UINavigationController *)addSiteNavigationController {
|
||
if (!_addSiteNavigationController) {
|
||
self.addSiteNavigationController = [[UINavigationController alloc] initWithRootViewController:self.addSiteViewController];
|
||
self.addSiteNavigationController.delegate = self;
|
||
}
|
||
|
||
return _addSiteNavigationController;
|
||
}
|
||
|
||
- (UINavigationController *)fontSettingsNavigationController {
|
||
if (!_fontSettingsNavigationController) {
|
||
self.fontSettingsNavigationController = [[UINavigationController alloc] initWithRootViewController:self.fontSettingsViewController];
|
||
self.fontSettingsNavigationController.delegate = self;
|
||
}
|
||
|
||
return _fontSettingsNavigationController;
|
||
}
|
||
|
||
- (void)closeOriginalStory {
|
||
if (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad) {
|
||
[self.masterContainerViewController transitionFromOriginalView];
|
||
} else {
|
||
if ([[navigationController viewControllers] containsObject:originalStoryViewController]) {
|
||
[navigationController popToViewController:storyPageControl animated:YES];
|
||
}
|
||
}
|
||
}
|
||
|
||
- (void)hideStoryDetailView {
|
||
if (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad) {
|
||
[self.masterContainerViewController transitionFromFeedDetail];
|
||
} else {
|
||
[self.navigationController popViewControllerAnimated:YES];
|
||
}
|
||
}
|
||
|
||
#pragma mark -
|
||
#pragma mark Siri Shortcuts
|
||
|
||
- (void)handleUserActivity:(NSUserActivity *)activity {
|
||
if ([activity.activityType isEqualToString:@"com.newsblur.refresh"]) {
|
||
[self.navigationController popToRootViewControllerAnimated:NO];
|
||
[self.feedsViewController refreshFeedList];
|
||
} else if ([activity.activityType isEqualToString:@"com.newsblur.gotoFolder"]) {
|
||
NSString *folder = activity.userInfo[@"folder"];
|
||
|
||
[self.navigationController popToRootViewControllerAnimated:NO];
|
||
[self loadRiverFeedDetailView:self.feedDetailViewController withFolder:folder];
|
||
} else if ([activity.activityType isEqualToString:@"com.newsblur.gotoFeed"]) {
|
||
NSString *folder = activity.userInfo[@"folder"];
|
||
NSString *feedID = activity.userInfo[@"feedID"];
|
||
|
||
[self.navigationController popToRootViewControllerAnimated:NO];
|
||
[self loadFolder:folder feedID:feedID];
|
||
}
|
||
}
|
||
|
||
- (void)donateRefresh {
|
||
NSUserActivity *activity = [[NSUserActivity alloc] initWithActivityType:@"com.newsblur.refresh"];
|
||
|
||
activity.title = @"Refresh NewsBlur";
|
||
activity.userInfo = @{};
|
||
activity.requiredUserInfoKeys = [NSSet new];
|
||
activity.eligibleForSearch = YES;
|
||
|
||
if (@available(iOS 12.0, *)) {
|
||
activity.eligibleForPrediction = YES;
|
||
activity.suggestedInvocationPhrase = @"Refresh NewsBlur";
|
||
}
|
||
|
||
CSSearchableItemAttributeSet *attributes = [[CSSearchableItemAttributeSet alloc] initWithItemContentType:(NSString *)kUTTypeItem];
|
||
|
||
attributes.contentDescription = @"Fetch new stories in NewsBlur.";
|
||
|
||
activity.contentAttributeSet = attributes;
|
||
|
||
self.userActivity = activity;
|
||
[self.userActivity becomeCurrent];
|
||
}
|
||
|
||
- (void)donateFolder {
|
||
NSUserActivity *activity = [[NSUserActivity alloc] initWithActivityType:@"com.newsblur.gotoFolder"];
|
||
NSString *folder = storiesCollection.activeFolder;
|
||
NSString *title = storiesCollection.activeTitle;
|
||
|
||
if (folder == nil || title == nil) {
|
||
return;
|
||
} else if ([folder isEqualToString:@"river_blurblogs"]) {
|
||
activity.title = @"Read All Shared Stories";
|
||
} else if ([folder isEqualToString:@"river_global"]) {
|
||
activity.title = @"Read Global Shared Stories";
|
||
} else if ([folder isEqualToString:@"everything"]) {
|
||
activity.title = @"Read All the Stories";
|
||
} else if ([folder isEqualToString:@"infrequent"]) {
|
||
activity.title = @"Read Infrequent Site Stories";
|
||
} else if (storiesCollection.isSavedView && storiesCollection.activeSavedStoryTag) {
|
||
activity.title = [NSString stringWithFormat:@"Read %@", storiesCollection.activeSavedStoryTag];
|
||
} else if ([folder isEqualToString:@"read_stories"]) {
|
||
activity.title = @"Re-read Stories";
|
||
} else if ([folder isEqualToString:@"saved_searches"]) {
|
||
activity.title = @"Re-read Saved Searches";
|
||
} else if ([folder isEqualToString:@"saved_stories"]) {
|
||
activity.title = @"Re-read Saved Stories";
|
||
} else {
|
||
activity.title = [NSString stringWithFormat:@"Read %@", title];
|
||
}
|
||
|
||
activity.userInfo = @{@"folder" : folder};
|
||
activity.requiredUserInfoKeys = [NSSet setWithObject:@"folder"];
|
||
activity.eligibleForSearch = YES;
|
||
|
||
if (@available(iOS 12.0, *)) {
|
||
activity.eligibleForPrediction = YES;
|
||
activity.suggestedInvocationPhrase = activity.title;
|
||
}
|
||
|
||
CSSearchableItemAttributeSet *attributes = [[CSSearchableItemAttributeSet alloc] initWithItemContentType:(NSString *)kUTTypeItem];
|
||
|
||
attributes.contentDescription = [NSString stringWithFormat:@"Go to the %@ folder in NewsBlur.", title];
|
||
|
||
activity.contentAttributeSet = attributes;
|
||
|
||
self.userActivity = activity;
|
||
[self.userActivity becomeCurrent];
|
||
}
|
||
|
||
- (void)donateFeed {
|
||
NSUserActivity *activity = [[NSUserActivity alloc] initWithActivityType:@"com.newsblur.gotoFeed"];
|
||
NSString *folder = storiesCollection.activeFolder;
|
||
NSDictionary *feed = storiesCollection.activeFeed;
|
||
NSString *title = storiesCollection.activeTitle;
|
||
NSString *feedID = [NSString stringWithFormat:@"%@", feed[@"id"]];
|
||
|
||
activity.title = [NSString stringWithFormat:@"Read %@", title];
|
||
activity.eligibleForSearch = YES;
|
||
|
||
if (folder != nil) {
|
||
activity.userInfo = @{@"folder" : folder, @"feedID" : feedID};
|
||
activity.requiredUserInfoKeys = [NSSet setWithArray:@[@"folder", @"feedID"]];
|
||
} else {
|
||
activity.userInfo = @{@"feedID" : feedID};
|
||
activity.requiredUserInfoKeys = [NSSet setWithArray:@[@"feedID"]];
|
||
}
|
||
|
||
if (@available(iOS 12.0, *)) {
|
||
activity.eligibleForPrediction = YES;
|
||
activity.suggestedInvocationPhrase = activity.title;
|
||
}
|
||
|
||
CSSearchableItemAttributeSet *attributes = [[CSSearchableItemAttributeSet alloc] initWithItemContentType:(NSString *)kUTTypeItem];
|
||
BOOL isSocial = [self isSocialFeed:feedID];
|
||
BOOL isSaved = [self isSavedFeed:feedID];
|
||
UIImage *thumbnailImage = [self getFavicon:feedID isSocial:isSocial isSaved:isSaved];
|
||
UIImage *scaledImage = [Utilities imageWithImage:thumbnailImage convertToSize:CGSizeMake(128, 128)];
|
||
|
||
attributes.contentDescription = [NSString stringWithFormat:@"Go to the %@ feed in NewsBlur.", title];
|
||
attributes.thumbnailData = UIImagePNGRepresentation(scaledImage);
|
||
|
||
activity.contentAttributeSet = attributes;
|
||
|
||
self.userActivity = activity;
|
||
[self.userActivity becomeCurrent];
|
||
}
|
||
|
||
#pragma mark - Text View
|
||
|
||
- (void)populateDictTextFeeds {
|
||
NSUserDefaults *preferences = [NSUserDefaults standardUserDefaults];
|
||
NSDictionary *textFeeds = [preferences dictionaryForKey:@"feeds:text"];
|
||
if (!textFeeds) {
|
||
self.dictTextFeeds = [[NSMutableDictionary alloc] init];
|
||
} else {
|
||
self.dictTextFeeds = [textFeeds mutableCopy];
|
||
}
|
||
|
||
}
|
||
|
||
- (BOOL)isFeedInTextView:(id)feedId {
|
||
id text = [self.dictTextFeeds objectForKey:feedId];
|
||
if (text != nil) return YES;
|
||
return NO;
|
||
}
|
||
|
||
- (void)toggleFeedTextView:(id)feedId {
|
||
NSUserDefaults *preferences = [NSUserDefaults standardUserDefaults];
|
||
if ([self.dictTextFeeds objectForKey:feedId]) {
|
||
[self.dictTextFeeds removeObjectForKey:feedId];
|
||
} else {
|
||
[self.dictTextFeeds setObject:[NSNumber numberWithBool:YES] forKey:feedId];
|
||
}
|
||
|
||
[preferences setObject:self.dictTextFeeds forKey:@"feeds:text"];
|
||
[preferences synchronize];
|
||
}
|
||
|
||
#pragma mark - Unread Counts
|
||
|
||
- (void)populateDictUnreadCounts {
|
||
[self.database inDatabase:^(FMDatabase *db) {
|
||
FMResultSet *cursor = [db executeQuery:@"SELECT * FROM unread_counts"];
|
||
|
||
while ([cursor next]) {
|
||
NSDictionary *unreadCounts = [cursor resultDictionary];
|
||
[self.dictUnreadCounts setObject:unreadCounts forKey:[unreadCounts objectForKey:@"feed_id"]];
|
||
}
|
||
|
||
[cursor close];
|
||
}];
|
||
}
|
||
|
||
- (NSInteger)unreadCount {
|
||
if (storiesCollection.isRiverView || storiesCollection.isSocialRiverView) {
|
||
return [self unreadCountForFolder:nil];
|
||
} else {
|
||
return [self unreadCountForFeed:nil];
|
||
}
|
||
}
|
||
|
||
- (NSInteger)allUnreadCount {
|
||
NSInteger total = 0;
|
||
for (id key in self.dictSocialFeeds) {
|
||
NSDictionary *feed = [self.dictSocialFeeds objectForKey:key];
|
||
total += [[feed objectForKey:@"ps"] integerValue];
|
||
total += [[feed objectForKey:@"nt"] integerValue];
|
||
NSLog(@"feed title and number is %@ %i", [feed objectForKey:@"feed_title"], ([[feed objectForKey:@"ps"] intValue] + [[feed objectForKey:@"nt"] intValue]));
|
||
NSLog(@"total is %ld", (long)total);
|
||
}
|
||
|
||
for (id key in self.dictUnreadCounts) {
|
||
NSDictionary *feed = [self.dictUnreadCounts objectForKey:key];
|
||
total += [[feed objectForKey:@"ps"] intValue];
|
||
total += [[feed objectForKey:@"nt"] intValue];
|
||
// NSLog(@"feed title and number is %@ %i", [feed objectForKey:@"feed_title"], ([[feed objectForKey:@"ps"] intValue] + [[feed objectForKey:@"nt"] intValue]));
|
||
// NSLog(@"total is %i", total);
|
||
}
|
||
|
||
return total;
|
||
}
|
||
|
||
- (NSInteger)unreadCountForFeed:(NSString *)feedId {
|
||
NSInteger total = 0;
|
||
NSDictionary *feed;
|
||
|
||
if (feedId) {
|
||
NSString *feedIdStr = [NSString stringWithFormat:@"%@",feedId];
|
||
if ([feedIdStr containsString:@"social:"]) {
|
||
feed = [self.dictSocialFeeds objectForKey:feedIdStr];
|
||
} else {
|
||
feed = [self.dictUnreadCounts objectForKey:feedIdStr];
|
||
}
|
||
|
||
} else {
|
||
NSString *feedIdStr = [NSString stringWithFormat:@"%@", [storiesCollection.activeFeed objectForKey:@"id"]];
|
||
feed = [self.dictUnreadCounts objectForKey:feedIdStr];
|
||
}
|
||
|
||
total += [[feed objectForKey:@"ps"] intValue];
|
||
if (self.isSavedStoriesIntelligenceMode) {
|
||
NSInteger savedCount = [self.dictSavedStoryFeedCounts[feedId] integerValue];
|
||
total += savedCount;
|
||
}
|
||
if ([self selectedIntelligence] <= 0) {
|
||
total += [[feed objectForKey:@"nt"] intValue];
|
||
}
|
||
if ([self selectedIntelligence] <= -1) {
|
||
total += [[feed objectForKey:@"ng"] intValue];
|
||
}
|
||
|
||
return total;
|
||
}
|
||
|
||
- (NSInteger)unreadCountForFolder:(NSString *)folderName {
|
||
NSInteger total = 0;
|
||
NSArray *folder;
|
||
|
||
if ([folderName isEqual:@"river_blurblogs"] ||
|
||
(!folderName && [storiesCollection.activeFolder isEqual:@"river_blurblogs"])) {
|
||
for (id feedId in self.dictSocialFeeds) {
|
||
total += [self unreadCountForFeed:feedId];
|
||
}
|
||
} else if ([folderName isEqual:@"river_global"] ||
|
||
(!folderName && [storiesCollection.activeFolder isEqual:@"river_global"])) {
|
||
total = 0;
|
||
} else if ([folderName isEqual:@"everything"] ||
|
||
[folderName isEqual:@"infrequent"] ||
|
||
(!folderName && ([storiesCollection.activeFolder isEqual:@"everything"] ||
|
||
[storiesCollection.activeFolder isEqual:@"infrequent"]))) {
|
||
// TODO: Fix race condition where self.dictUnreadCounts can be changed while being updated.
|
||
for (id feedId in self.dictUnreadCounts) {
|
||
total += [self unreadCountForFeed:feedId];
|
||
}
|
||
} else {
|
||
if (!folderName) {
|
||
folder = [self.dictFolders objectForKey:storiesCollection.activeFolder];
|
||
} else {
|
||
folder = [self.dictFolders objectForKey:folderName];
|
||
}
|
||
|
||
for (id feedId in folder) {
|
||
total += [self unreadCountForFeed:feedId];
|
||
}
|
||
}
|
||
|
||
return total;
|
||
}
|
||
|
||
|
||
- (UnreadCounts *)splitUnreadCountForFeed:(NSString *)feedId {
|
||
UnreadCounts *counts = [UnreadCounts alloc];
|
||
NSDictionary *feedCounts;
|
||
|
||
if (!feedId) {
|
||
feedId = [storiesCollection.activeFeed objectForKey:@"id"];
|
||
}
|
||
NSString *feedIdStr = [NSString stringWithFormat:@"%@", feedId];
|
||
feedCounts = [self.dictUnreadCounts objectForKey:feedIdStr];
|
||
|
||
counts.ps += [[feedCounts objectForKey:@"ps"] intValue];
|
||
counts.nt += [[feedCounts objectForKey:@"nt"] intValue];
|
||
counts.ng += [[feedCounts objectForKey:@"ng"] intValue];
|
||
|
||
return counts;
|
||
}
|
||
|
||
- (UnreadCounts *)splitUnreadCountForFolder:(NSString *)folderName {
|
||
UnreadCounts *counts = [UnreadCounts alloc];
|
||
NSArray *folder;
|
||
|
||
if ([[self.folderCountCache objectForKey:folderName] boolValue]) {
|
||
counts.ps = [[self.folderCountCache objectForKey:[NSString stringWithFormat:@"%@-ps", folderName]] intValue];
|
||
counts.nt = [[self.folderCountCache objectForKey:[NSString stringWithFormat:@"%@-nt", folderName]] intValue];
|
||
counts.ng = [[self.folderCountCache objectForKey:[NSString stringWithFormat:@"%@-ng", folderName]] intValue];
|
||
return counts;
|
||
}
|
||
|
||
if ([folderName isEqual:@"river_blurblogs"] ||
|
||
(!folderName && [storiesCollection.activeFolder isEqual:@"river_blurblogs"])) {
|
||
for (id feedId in self.dictSocialFeeds) {
|
||
[counts addCounts:[self splitUnreadCountForFeed:feedId]];
|
||
}
|
||
} else if ([folderName isEqual:@"river_global"] ||
|
||
(!folderName && [storiesCollection.activeFolder isEqual:@"river_global"])) {
|
||
// Nothing for global
|
||
} else if ([folderName isEqual:@"everything"] ||
|
||
[folderName isEqual:@"infrequent"] ||
|
||
(!folderName && ([storiesCollection.activeFolder isEqual:@"everything"] ||
|
||
[storiesCollection.activeFolder isEqual:@"infrequent"]))) {
|
||
for (NSArray *folder in [self.dictFolders allValues]) {
|
||
for (id feedId in folder) {
|
||
if ([feedId isKindOfClass:[NSString class]] && [feedId startsWith:@"saved:"]) {
|
||
// Skip saved feeds which have fake unread counts.
|
||
continue;
|
||
}
|
||
[counts addCounts:[self splitUnreadCountForFeed:feedId]];
|
||
}
|
||
}
|
||
} else {
|
||
if (!folderName) {
|
||
folder = [self.dictFolders objectForKey:storiesCollection.activeFolder];
|
||
} else {
|
||
folder = [self.dictFolders objectForKey:folderName];
|
||
}
|
||
|
||
for (id feedId in folder) {
|
||
[counts addCounts:[self splitUnreadCountForFeed:feedId]];
|
||
}
|
||
}
|
||
|
||
if (!self.folderCountCache) {
|
||
self.folderCountCache = [[NSMutableDictionary alloc] init];
|
||
}
|
||
[self.folderCountCache setObject:[NSNumber numberWithBool:YES] forKey:folderName];
|
||
[self.folderCountCache setObject:[NSNumber numberWithInt:counts.ps] forKey:[NSString stringWithFormat:@"%@-ps", folderName]];
|
||
[self.folderCountCache setObject:[NSNumber numberWithInt:counts.nt] forKey:[NSString stringWithFormat:@"%@-nt", folderName]];
|
||
[self.folderCountCache setObject:[NSNumber numberWithInt:counts.ng] forKey:[NSString stringWithFormat:@"%@-ng", folderName]];
|
||
|
||
return counts;
|
||
}
|
||
|
||
- (BOOL)isFolderCollapsed:(NSString *)folderName {
|
||
if (!self.collapsedFolders) {
|
||
self.collapsedFolders = [[NSMutableDictionary alloc] init];
|
||
NSUserDefaults *userPreferences = [NSUserDefaults standardUserDefaults];
|
||
for (NSString *folderName in self.dictFoldersArray) {
|
||
NSString *collapseKey = [NSString stringWithFormat:@"folderCollapsed:%@",
|
||
folderName];
|
||
if ([userPreferences boolForKey:collapseKey]) {
|
||
[self.collapsedFolders setObject:folderName forKey:folderName];
|
||
}
|
||
}
|
||
}
|
||
return !![self.collapsedFolders objectForKey:folderName];
|
||
}
|
||
|
||
#pragma mark - Story Management
|
||
|
||
- (NSDictionary *)markVisibleStoriesRead {
|
||
NSMutableDictionary *feedsStories = [NSMutableDictionary dictionary];
|
||
for (NSDictionary *story in storiesCollection.activeFeedStories) {
|
||
if ([[story objectForKey:@"read_status"] intValue] != 0) {
|
||
continue;
|
||
}
|
||
NSString *feedIdStr = [NSString stringWithFormat:@"%@",[story objectForKey:@"story_feed_id"]];
|
||
NSDictionary *feed = [self getFeed:feedIdStr];
|
||
if (![feedsStories objectForKey:feedIdStr]) {
|
||
[feedsStories setObject:[NSMutableArray array] forKey:feedIdStr];
|
||
}
|
||
NSMutableArray *stories = [feedsStories objectForKey:feedIdStr];
|
||
[stories addObject:[story objectForKey:@"story_hash"]];
|
||
[storiesCollection markStoryRead:story feed:feed];
|
||
}
|
||
return feedsStories;
|
||
}
|
||
|
||
#pragma mark -
|
||
#pragma mark Mark as read
|
||
|
||
- (void)markActiveFolderAllRead {
|
||
if ([storiesCollection.activeFolder isEqual:@"everything"] || [storiesCollection.activeFolder isEqual:@"infrequent"]) {
|
||
for (NSString *folderName in self.dictFoldersArray) {
|
||
for (id feedId in [self.dictFolders objectForKey:folderName]) {
|
||
[self markFeedAllRead:feedId];
|
||
}
|
||
}
|
||
} else {
|
||
for (id feedId in [self.dictFolders objectForKey:storiesCollection.activeFolder]) {
|
||
[self markFeedAllRead:feedId];
|
||
}
|
||
}
|
||
}
|
||
|
||
- (void)markFeedAllRead:(id)feedId {
|
||
NSString *feedIdStr = [NSString stringWithFormat:@"%@",feedId];
|
||
NSMutableDictionary *unreadCounts = [NSMutableDictionary dictionary];
|
||
|
||
[unreadCounts setValue:[NSNumber numberWithInt:0] forKey:@"ps"];
|
||
[unreadCounts setValue:[NSNumber numberWithInt:0] forKey:@"nt"];
|
||
[unreadCounts setValue:[NSNumber numberWithInt:0] forKey:@"ng"];
|
||
|
||
[self.dictUnreadCounts setObject:unreadCounts forKey:feedIdStr];
|
||
}
|
||
|
||
- (void)markFeedReadInCache:(NSArray *)feedIds {
|
||
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0ul);
|
||
dispatch_async(queue, ^{
|
||
[self.database inTransaction:^(FMDatabase *db, BOOL *rollback) {
|
||
[db executeUpdate:[NSString
|
||
stringWithFormat:@"UPDATE unread_counts SET ps = 0, nt = 0, ng = 0 "
|
||
"WHERE feed_id IN (\"%@\")",
|
||
[feedIds componentsJoinedByString:@"\",\""]]];
|
||
[db executeUpdate:[NSString
|
||
stringWithFormat:@"DELETE FROM unread_hashes "
|
||
"WHERE story_feed_id IN (\"%@\")",
|
||
[feedIds componentsJoinedByString:@"\",\""]]];
|
||
}];
|
||
});
|
||
}
|
||
|
||
- (void)markFeedReadInCache:(NSArray *)feedIds cutoffTimestamp:(NSInteger)cutoff {
|
||
[self markFeedReadInCache:feedIds cutoffTimestamp:cutoff older:YES];
|
||
}
|
||
|
||
- (void)markFeedReadInCache:(NSArray *)feedIds cutoffTimestamp:(NSInteger)cutoff older:(BOOL)older {
|
||
for (NSString *feedId in feedIds) {
|
||
NSString *feedIdString = [NSString stringWithFormat:@"%@", feedId];
|
||
NSDictionary *unreadCounts = [self.dictUnreadCounts objectForKey:feedIdString];
|
||
NSMutableDictionary *newUnreadCounts = [unreadCounts mutableCopy];
|
||
NSMutableArray *stories = [NSMutableArray array];
|
||
NSString *direction = older ? @"<" : @">";
|
||
|
||
[self.database inDatabase:^(FMDatabase *db) {
|
||
NSString *sql = [NSString stringWithFormat:@"SELECT * FROM stories s "
|
||
"INNER JOIN unread_hashes uh ON s.story_hash = uh.story_hash "
|
||
"WHERE s.story_feed_id = %@ AND s.story_timestamp %@ %ld",
|
||
feedIdString, direction, (long)cutoff];
|
||
FMResultSet *cursor = [db executeQuery:sql];
|
||
|
||
while ([cursor next]) {
|
||
NSDictionary *story = [cursor resultDictionary];
|
||
[stories addObject:[NSJSONSerialization
|
||
JSONObjectWithData:[[story objectForKey:@"story_json"]
|
||
dataUsingEncoding:NSUTF8StringEncoding]
|
||
options:0 error:nil]];
|
||
}
|
||
|
||
[cursor close];
|
||
}];
|
||
|
||
for (NSDictionary *story in stories) {
|
||
NSInteger score = [NewsBlurAppDelegate computeStoryScore:[story objectForKey:@"intelligence"]];
|
||
if (score > 0) {
|
||
int unreads = MAX(0, [[newUnreadCounts objectForKey:@"ps"] intValue] - 1);
|
||
[newUnreadCounts setValue:[NSNumber numberWithInt:unreads] forKey:@"ps"];
|
||
} else if (score == 0) {
|
||
int unreads = MAX(0, [[newUnreadCounts objectForKey:@"nt"] intValue] - 1);
|
||
[newUnreadCounts setValue:[NSNumber numberWithInt:unreads] forKey:@"nt"];
|
||
} else if (score < 0) {
|
||
int unreads = MAX(0, [[newUnreadCounts objectForKey:@"ng"] intValue] - 1);
|
||
[newUnreadCounts setValue:[NSNumber numberWithInt:unreads] forKey:@"ng"];
|
||
}
|
||
[self.dictUnreadCounts setObject:newUnreadCounts forKey:feedIdString];
|
||
}
|
||
|
||
[self.database inTransaction:^(FMDatabase *db, BOOL *rollback) {
|
||
for (NSDictionary *story in stories) {
|
||
NSMutableDictionary *newStory = [story mutableCopy];
|
||
[newStory setObject:[NSNumber numberWithInt:1] forKey:@"read_status"];
|
||
NSString *storyHash = [newStory objectForKey:@"story_hash"];
|
||
[db executeUpdate:@"UPDATE stories SET story_json = ? WHERE story_hash = ?",
|
||
[newStory JSONRepresentation],
|
||
storyHash];
|
||
}
|
||
NSString *deleteSql = [NSString
|
||
stringWithFormat:@"DELETE FROM unread_hashes "
|
||
"WHERE story_feed_id = \"%@\" "
|
||
"AND story_timestamp < %ld",
|
||
feedIdString, (long)cutoff];
|
||
[db executeUpdate:deleteSql];
|
||
[db executeUpdate:@"UPDATE unread_counts SET ps = ?, nt = ?, ng = ? WHERE feed_id = ?",
|
||
[newUnreadCounts objectForKey:@"ps"],
|
||
[newUnreadCounts objectForKey:@"nt"],
|
||
[newUnreadCounts objectForKey:@"ng"],
|
||
feedIdString];
|
||
}];
|
||
}
|
||
}
|
||
|
||
- (void)markStoryAsRead:(NSString *)storyHash inFeed:(NSString *)feed withCallback:(void(^)(void))callback {
|
||
NSString *urlString = [NSString stringWithFormat:@"%@/reader/mark_story_hashes_as_read",
|
||
self.url];
|
||
NSMutableDictionary *params = [NSMutableDictionary dictionary];
|
||
[params setObject:storyHash forKey:@"story_hash"];
|
||
|
||
[self POST:urlString parameters:params success:^(NSURLSessionDataTask * _Nonnull task, id _Nullable responseObject) {
|
||
NSLog(@"Marked as read: %@", storyHash);
|
||
callback();
|
||
} failure:^(NSURLSessionDataTask * _Nullable task, NSError * _Nonnull error) {
|
||
NSLog(@"Failed marked as read, queueing: %@", storyHash);
|
||
NSMutableDictionary *stories = [NSMutableDictionary dictionary];
|
||
[stories setObject:@[storyHash] forKey:feed];
|
||
[self queueReadStories:stories];
|
||
callback();
|
||
}];
|
||
}
|
||
|
||
- (void)markStoryAsStarred:(NSString *)storyHash withCallback:(void(^)(void))callback {
|
||
NSString *urlString = [NSString stringWithFormat:@"%@/reader/mark_story_hash_as_starred",
|
||
self.url];
|
||
NSMutableDictionary *params = [NSMutableDictionary dictionary];
|
||
[params setObject:storyHash forKey:@"story_hash"];
|
||
|
||
[self POST:urlString parameters:params success:^(NSURLSessionDataTask * _Nonnull task, id _Nullable responseObject) {
|
||
NSLog(@"Marked as starred: %@", storyHash);
|
||
callback();
|
||
} failure:^(NSURLSessionDataTask * _Nullable task, NSError * _Nonnull error) {
|
||
NSLog(@"Failed marked as starred: %@", storyHash);
|
||
callback();
|
||
}];
|
||
}
|
||
|
||
- (void)markStoriesRead:(NSDictionary *)stories inFeeds:(NSArray *)feeds cutoffTimestamp:(NSInteger)cutoff {
|
||
// Must be offline and marking all as read, so load all stories.
|
||
|
||
if (stories && [[stories allKeys] count]) {
|
||
[self queueReadStories:stories];
|
||
}
|
||
|
||
if ([feeds count]) {
|
||
NSMutableDictionary *feedsStories = [NSMutableDictionary dictionary];
|
||
|
||
[self.database inDatabase:^(FMDatabase *db) {
|
||
NSString *sql = [NSString stringWithFormat:@"SELECT u.story_feed_id, u.story_hash "
|
||
"FROM unread_hashes u WHERE u.story_feed_id IN (\"%@\")",
|
||
[feeds componentsJoinedByString:@"\",\""]];
|
||
if (cutoff) {
|
||
sql = [NSString stringWithFormat:@"%@ AND u.story_timestamp < %ld", sql, (long)cutoff];
|
||
}
|
||
FMResultSet *cursor = [db executeQuery:sql];
|
||
|
||
while ([cursor next]) {
|
||
NSDictionary *story = [cursor resultDictionary];
|
||
NSString *feedIdStr = [story objectForKey:@"story_feed_id"];
|
||
NSString *storyHash = [story objectForKey:@"story_hash"];
|
||
|
||
if (![feedsStories objectForKey:feedIdStr]) {
|
||
[feedsStories setObject:[NSMutableArray array] forKey:feedIdStr];
|
||
}
|
||
|
||
NSMutableArray *stories = [feedsStories objectForKey:feedIdStr];
|
||
[stories addObject:storyHash];
|
||
}
|
||
|
||
[cursor close];
|
||
}];
|
||
[self queueReadStories:feedsStories];
|
||
if (cutoff) {
|
||
[self markFeedReadInCache:[feedsStories allKeys] cutoffTimestamp:cutoff];
|
||
} else {
|
||
for (NSString *feedId in [feedsStories allKeys]) {
|
||
[self markFeedAllRead:feedId];
|
||
}
|
||
[self markFeedReadInCache:[feedsStories allKeys]];
|
||
}
|
||
}
|
||
}
|
||
|
||
- (void)finishMarkAsRead:(NSDictionary *)story {
|
||
if (!storyPageControl.previousPage || !storyPageControl.currentPage || !storyPageControl.nextPage) return;
|
||
for (StoryDetailViewController *page in @[storyPageControl.previousPage,
|
||
storyPageControl.currentPage,
|
||
storyPageControl.nextPage]) {
|
||
if ([[page.activeStory objectForKey:@"story_hash"]
|
||
isEqualToString:[story objectForKey:@"story_hash"]] && page.isRecentlyUnread) {
|
||
page.isRecentlyUnread = NO;
|
||
[storyPageControl refreshHeaders];
|
||
}
|
||
}
|
||
}
|
||
|
||
- (void)finishMarkAsUnread:(NSDictionary *)story {
|
||
if (!storyPageControl.previousPage || !storyPageControl.currentPage || !storyPageControl.nextPage) return;
|
||
for (StoryDetailViewController *page in @[storyPageControl.previousPage,
|
||
storyPageControl.currentPage,
|
||
storyPageControl.nextPage]) {
|
||
if ([[page.activeStory objectForKey:@"story_hash"]
|
||
isEqualToString:[story objectForKey:@"story_hash"]]) {
|
||
page.isRecentlyUnread = YES;
|
||
[storyPageControl refreshHeaders];
|
||
}
|
||
}
|
||
[storyPageControl setNextPreviousButtons];
|
||
originalStoryCount += 1;
|
||
}
|
||
|
||
- (void)failedMarkAsUnread:(NSDictionary *)params {
|
||
if (![storyPageControl failedMarkAsUnread:params]) {
|
||
[feedDetailViewController failedMarkAsUnread:params];
|
||
[dashboardViewController.storiesModule failedMarkAsUnread:params];
|
||
[storyPageControl failedMarkAsUnread:params];
|
||
}
|
||
[feedDetailViewController reloadData];
|
||
[dashboardViewController.storiesModule reloadData];
|
||
}
|
||
|
||
- (void)finishMarkAsSaved:(NSDictionary *)params {
|
||
[storyPageControl finishMarkAsSaved:params];
|
||
[feedDetailViewController finishMarkAsSaved:params];
|
||
}
|
||
|
||
- (void)failedMarkAsSaved:(NSDictionary *)params {
|
||
if (![storyPageControl failedMarkAsSaved:params]) {
|
||
[feedDetailViewController failedMarkAsSaved:params];
|
||
[dashboardViewController.storiesModule failedMarkAsSaved:params];
|
||
[storyPageControl failedMarkAsSaved:params];
|
||
}
|
||
[feedDetailViewController reloadData];
|
||
[dashboardViewController.storiesModule reloadData];
|
||
}
|
||
|
||
- (void)finishMarkAsUnsaved:(NSDictionary *)params {
|
||
[storyPageControl finishMarkAsUnsaved:params];
|
||
[feedDetailViewController finishMarkAsUnsaved:params];
|
||
}
|
||
|
||
- (void)failedMarkAsUnsaved:(NSDictionary *)params {
|
||
if (![storyPageControl failedMarkAsUnsaved:params]) {
|
||
[feedDetailViewController failedMarkAsUnsaved:params];
|
||
[dashboardViewController.storiesModule failedMarkAsUnsaved:params];
|
||
[storyPageControl failedMarkAsUnsaved:params];
|
||
}
|
||
[feedDetailViewController reloadData];
|
||
[dashboardViewController.storiesModule reloadData];
|
||
}
|
||
|
||
|
||
- (NSInteger)adjustSavedStoryCount:(NSString *)tagName direction:(NSInteger)direction {
|
||
NSString *savedTagId = [NSString stringWithFormat:@"saved:%@", tagName];
|
||
NSMutableDictionary *newTag = [[self.dictSavedStoryTags objectForKey:savedTagId] mutableCopy];
|
||
if (!newTag) {
|
||
newTag = [@{@"ps": [NSNumber numberWithInt:0],
|
||
@"feed_title": tagName
|
||
} mutableCopy];
|
||
}
|
||
NSInteger newCount = [[newTag objectForKey:@"ps"] integerValue] + direction;
|
||
[newTag setObject:[NSNumber numberWithInteger:newCount] forKey:@"ps"];
|
||
NSMutableDictionary *savedStoryDict = [[NSMutableDictionary alloc] init];
|
||
for (NSString *tagId in [self.dictSavedStoryTags allKeys]) {
|
||
if ([tagId isEqualToString:savedTagId]) {
|
||
if (newCount > 0) {
|
||
[savedStoryDict setObject:newTag forKey:tagId];
|
||
}
|
||
} else {
|
||
[savedStoryDict setObject:[self.dictSavedStoryTags objectForKey:tagId]
|
||
forKey:tagId];
|
||
}
|
||
}
|
||
|
||
// If adding a tag, it won't already be in dictSavedStoryTags
|
||
if (![self.dictSavedStoryTags objectForKey:savedStoryDict] && newCount > 0) {
|
||
[savedStoryDict setObject:newTag forKey:savedTagId];
|
||
}
|
||
self.dictSavedStoryTags = savedStoryDict;
|
||
|
||
return newCount;
|
||
}
|
||
|
||
- (NSArray *)updateStarredStoryCounts:(NSDictionary *)results {
|
||
if ([results objectForKey:@"starred_count"]) {
|
||
self.savedStoriesCount = [[results objectForKey:@"starred_count"] intValue];
|
||
}
|
||
|
||
if (!self.savedStoriesCount) return [[NSArray alloc] init];
|
||
|
||
NSMutableDictionary *savedStoryDict = [NSMutableDictionary dictionary];
|
||
NSMutableDictionary *savedStoryFeedCounts = [NSMutableDictionary dictionary];
|
||
NSMutableArray *savedStories = [NSMutableArray array];
|
||
|
||
if (![results objectForKey:@"starred_counts"] ||
|
||
[[results objectForKey:@"starred_counts"] isKindOfClass:[NSNull class]]) {
|
||
return savedStories;
|
||
}
|
||
|
||
for (NSDictionary *userTag in [results objectForKey:@"starred_counts"]) {
|
||
id feedId = [userTag objectForKey:@"feed_id"];
|
||
|
||
if (![feedId isKindOfClass:[NSNull class]]) {
|
||
NSString *feedIdStr = [NSString stringWithFormat:@"%@", feedId];
|
||
savedStoryFeedCounts[feedIdStr] = userTag[@"count"];
|
||
|
||
continue;
|
||
}
|
||
|
||
if ([[userTag objectForKey:@"tag"] isKindOfClass:[NSNull class]] ||
|
||
[[userTag objectForKey:@"tag"] isEqualToString:@""]) continue;
|
||
NSString *savedTagId = [NSString stringWithFormat:@"saved:%@", [userTag objectForKey:@"tag"]];
|
||
NSDictionary *savedTag = @{@"ps": [userTag objectForKey:@"count"],
|
||
@"feed_title": [userTag objectForKey:@"tag"],
|
||
@"id": [userTag objectForKey:@"tag"],
|
||
@"tag": [userTag objectForKey:@"tag"]};
|
||
[savedStories addObject:savedTagId];
|
||
[savedStoryDict setObject:savedTag forKey:savedTagId];
|
||
[self.dictUnreadCounts setObject:@{@"ps": [userTag objectForKey:@"count"],
|
||
@"nt": [NSNumber numberWithInt:0],
|
||
@"ng": [NSNumber numberWithInt:0]}
|
||
forKey:savedTagId];
|
||
}
|
||
|
||
self.dictSavedStoryTags = savedStoryDict;
|
||
self.dictSavedStoryFeedCounts = savedStoryFeedCounts;
|
||
|
||
return savedStories;
|
||
}
|
||
|
||
- (NSArray *)updateSavedSearches:(NSDictionary *)results {
|
||
NSArray *savedSearches = results[@"saved_searches"];
|
||
NSInteger count = 0;
|
||
NSMutableArray *feedIds = [NSMutableArray arrayWithCapacity:savedSearches.count];
|
||
|
||
for (NSDictionary *search in savedSearches) {
|
||
NSString *feedStr = search[@"feed_id"];
|
||
NSString *prefix = @"feed:";
|
||
|
||
if ([feedStr hasPrefix:prefix]) {
|
||
feedStr = [feedStr substringFromIndex:prefix.length];
|
||
}
|
||
|
||
if ([feedStr isEqualToString:@"river:"]) {
|
||
feedStr = @"river:everything";
|
||
}
|
||
|
||
NSString *feedId = [NSString stringWithFormat:@"%@?%@", feedStr, search[@"query"]];
|
||
|
||
[feedIds addObject:feedId];
|
||
count++;
|
||
}
|
||
|
||
self.savedSearchesCount = count;
|
||
|
||
return feedIds;
|
||
}
|
||
|
||
- (void)renameFeed:(NSString *)newTitle {
|
||
NSMutableDictionary *newActiveFeed = [storiesCollection.activeFeed mutableCopy];
|
||
[newActiveFeed setObject:newTitle forKey:@"feed_title"];
|
||
storiesCollection.activeFeed = newActiveFeed;
|
||
}
|
||
|
||
- (void)renameFolder:(NSString *)newTitle {
|
||
storiesCollection.activeFolder = newTitle;
|
||
}
|
||
|
||
- (void)showMarkReadMenuWithFeedIds:(NSArray *)feedIds collectionTitle:(NSString *)collectionTitle visibleUnreadCount:(NSInteger)visibleUnreadCount barButtonItem:(UIBarButtonItem *)barButtonItem completionHandler:(void (^)(BOOL marked))completionHandler {
|
||
[self showMarkReadMenuWithFeedIds:feedIds collectionTitle:collectionTitle visibleUnreadCount:visibleUnreadCount olderNewerCollection:nil olderNewerStory:nil barButtonItem:barButtonItem sourceView:nil sourceRect:CGRectZero extraItems:nil completionHandler:completionHandler];
|
||
}
|
||
|
||
- (void)showMarkReadMenuWithFeedIds:(NSArray *)feedIds collectionTitle:(NSString *)collectionTitle sourceView:(UIView *)sourceView sourceRect:(CGRect)sourceRect completionHandler:(void (^)(BOOL marked))completionHandler {
|
||
[self showMarkReadMenuWithFeedIds:feedIds collectionTitle:collectionTitle visibleUnreadCount:0 olderNewerCollection:nil olderNewerStory:nil barButtonItem:nil sourceView:sourceView sourceRect:sourceRect extraItems:nil completionHandler:completionHandler];
|
||
}
|
||
|
||
- (void)showMarkOlderNewerReadMenuWithStoriesCollection:(StoriesCollection *)olderNewerCollection story:(NSDictionary *)olderNewerStory sourceView:(UIView *)sourceView sourceRect:(CGRect)sourceRect extraItems:(NSArray *)extraItems completionHandler:(void (^)(BOOL marked))completionHandler {
|
||
[self showMarkReadMenuWithFeedIds:nil collectionTitle:nil visibleUnreadCount:0 olderNewerCollection:storiesCollection olderNewerStory:olderNewerStory barButtonItem:nil sourceView:sourceView sourceRect:sourceRect extraItems:extraItems completionHandler:completionHandler];
|
||
}
|
||
|
||
- (void)showMarkReadMenuWithFeedIds:(NSArray *)feedIds collectionTitle:(NSString *)collectionTitle visibleUnreadCount:(NSInteger)visibleUnreadCount olderNewerCollection:(StoriesCollection *)olderNewerCollection olderNewerStory:(NSDictionary *)olderNewerStory barButtonItem:(UIBarButtonItem *)barButtonItem sourceView:(UIView *)sourceView sourceRect:(CGRect)sourceRect extraItems:(NSArray *)extraItems completionHandler:(void (^)(BOOL marked))completionHandler {
|
||
if (!self.markReadMenuViewController) {
|
||
self.markReadMenuViewController = [MarkReadMenuViewController new];
|
||
self.markReadMenuViewController.modalPresentationStyle = UIModalPresentationPopover;
|
||
}
|
||
|
||
self.markReadMenuViewController.collectionTitle = collectionTitle;
|
||
self.markReadMenuViewController.feedIds = feedIds;
|
||
self.markReadMenuViewController.visibleUnreadCount = visibleUnreadCount;
|
||
self.markReadMenuViewController.olderNewerStoriesCollection = olderNewerCollection;
|
||
self.markReadMenuViewController.olderNewerStory = olderNewerStory;
|
||
self.markReadMenuViewController.extraItems = extraItems;
|
||
self.markReadMenuViewController.completionHandler = completionHandler;
|
||
|
||
if (@available(iOS 13.0, *)) {
|
||
self.markReadMenuViewController.menuTableView.contentInsetAdjustmentBehavior = UIScrollViewContentInsetAdjustmentAlways;
|
||
}
|
||
|
||
[self showPopoverWithViewController:self.markReadMenuViewController contentSize:CGSizeZero barButtonItem:barButtonItem sourceView:sourceView sourceRect:sourceRect permittedArrowDirections:UIPopoverArrowDirectionAny];
|
||
}
|
||
|
||
- (void)showPopoverWithViewController:(UIViewController *)viewController contentSize:(CGSize)contentSize barButtonItem:(UIBarButtonItem *)barButtonItem {
|
||
[self showPopoverWithViewController:viewController contentSize:contentSize barButtonItem:barButtonItem sourceView:nil sourceRect:CGRectZero permittedArrowDirections:UIPopoverArrowDirectionAny];
|
||
}
|
||
|
||
- (void)showPopoverWithViewController:(UIViewController *)viewController contentSize:(CGSize)contentSize sourceView:(UIView *)sourceView sourceRect:(CGRect)sourceRect {
|
||
[self showPopoverWithViewController:viewController contentSize:contentSize barButtonItem:nil sourceView:sourceView sourceRect:sourceRect permittedArrowDirections:UIPopoverArrowDirectionAny];
|
||
}
|
||
|
||
- (void)showPopoverWithViewController:(UIViewController *)viewController contentSize:(CGSize)contentSize sourceView:(UIView *)sourceView sourceRect:(CGRect)sourceRect permittedArrowDirections:(UIPopoverArrowDirection)permittedArrowDirections {
|
||
[self showPopoverWithViewController:viewController contentSize:contentSize barButtonItem:nil sourceView:sourceView sourceRect:sourceRect permittedArrowDirections:permittedArrowDirections];
|
||
}
|
||
|
||
- (void)showPopoverWithViewController:(UIViewController *)viewController contentSize:(CGSize)contentSize barButtonItem:(UIBarButtonItem *)barButtonItem sourceView:(UIView *)sourceView sourceRect:(CGRect)sourceRect permittedArrowDirections:(UIPopoverArrowDirection)permittedArrowDirections {
|
||
if (viewController == self.navigationControllerForPopover.presentedViewController) {
|
||
return; // nothing to do, already showing this controller
|
||
}
|
||
|
||
[self hidePopoverAnimated:YES];
|
||
|
||
viewController.modalPresentationStyle = UIModalPresentationPopover;
|
||
viewController.preferredContentSize = contentSize;
|
||
|
||
if ([viewController respondsToSelector:@selector(addKeyCommand:)]) {
|
||
[viewController addKeyCommand:[UIKeyCommand keyCommandWithInput:@"." modifierFlags:UIKeyModifierCommand action:@selector(hidePopover)]];
|
||
[viewController addKeyCommand:[UIKeyCommand keyCommandWithInput:UIKeyInputEscape modifierFlags:0 action:@selector(hidePopover)]];
|
||
}
|
||
|
||
UIPopoverPresentationController *popoverPresentationController = viewController.popoverPresentationController;
|
||
popoverPresentationController.delegate = self;
|
||
popoverPresentationController.backgroundColor = UIColorFromRGB(NEWSBLUR_WHITE_COLOR);
|
||
popoverPresentationController.permittedArrowDirections = permittedArrowDirections;
|
||
|
||
if (barButtonItem) {
|
||
popoverPresentationController.barButtonItem = barButtonItem;
|
||
} else {
|
||
popoverPresentationController.sourceView = sourceView;
|
||
popoverPresentationController.sourceRect = sourceRect;
|
||
}
|
||
|
||
[self.navigationControllerForPopover presentViewController:viewController animated:YES completion:^{
|
||
popoverPresentationController.passthroughViews = nil;
|
||
// NSLog(@"%@ canBecomeFirstResponder? %d", viewController, viewController.canBecomeFirstResponder);
|
||
[viewController becomeFirstResponder];
|
||
}];
|
||
}
|
||
|
||
- (void)hidePopoverAnimated:(BOOL)animated completion:(void (^)(void))completion {
|
||
UIViewController *presentedViewController = self.navigationControllerForPopover.presentedViewController;
|
||
if (!presentedViewController || presentedViewController.presentationController.presentationStyle != UIModalPresentationPopover) {
|
||
if (completion) {
|
||
completion();
|
||
}
|
||
return;
|
||
}
|
||
|
||
[presentedViewController dismissViewControllerAnimated:animated completion:completion];
|
||
[self.navigationController.topViewController becomeFirstResponder];
|
||
}
|
||
|
||
- (BOOL)hidePopoverAnimated:(BOOL)animated {
|
||
UIViewController *presentedViewController = self.navigationControllerForPopover.presentedViewController;
|
||
if (!presentedViewController || presentedViewController.presentationController.presentationStyle != UIModalPresentationPopover)
|
||
return NO;
|
||
|
||
[presentedViewController dismissViewControllerAnimated:animated completion:nil];
|
||
[self.navigationController.topViewController becomeFirstResponder];
|
||
return YES;
|
||
}
|
||
|
||
- (void)hidePopover {
|
||
[self hidePopoverAnimated:YES];
|
||
[self.modalNavigationController dismissViewControllerAnimated:YES completion:nil];
|
||
}
|
||
|
||
- (UINavigationController *)navigationControllerForPopover {
|
||
if (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad) {
|
||
return self.masterContainerViewController.masterNavigationController;
|
||
} else {
|
||
return self.navigationController;
|
||
}
|
||
}
|
||
|
||
#pragma mark -
|
||
#pragma mark Story functions
|
||
|
||
+ (int)computeStoryScore:(NSDictionary *)intelligence {
|
||
int score = 0;
|
||
int title = [[intelligence objectForKey:@"title"] intValue];
|
||
int author = [[intelligence objectForKey:@"author"] intValue];
|
||
int tags = [[intelligence objectForKey:@"tags"] intValue];
|
||
|
||
int score_max = MAX(title, MAX(author, tags));
|
||
int score_min = MIN(title, MIN(author, tags));
|
||
|
||
if (score_max > 0) score = score_max;
|
||
else if (score_min < 0) score = score_min;
|
||
|
||
if (score == 0) score = [[intelligence objectForKey:@"feed"] intValue];
|
||
|
||
// NSLog(@"%d/%d -- %d: %@", score_max, score_min, score, intelligence);
|
||
return score;
|
||
}
|
||
|
||
#pragma mark - Feed Management
|
||
|
||
- (NSString *)extractParentFolderName:(NSString *)folderName {
|
||
if ([folderName containsString:@"Top Level"] ||
|
||
[folderName isEqual:@"everything"] ||
|
||
[folderName isEqual:@"infrequent"]) {
|
||
folderName = @"";
|
||
}
|
||
|
||
if ([folderName containsString:@" - "]) {
|
||
NSInteger lastFolderLoc = [folderName rangeOfString:@" - "
|
||
options:NSBackwardsSearch].location;
|
||
folderName = [folderName substringToIndex:lastFolderLoc];
|
||
} else {
|
||
folderName = @"— Top Level —";
|
||
}
|
||
|
||
return folderName;
|
||
}
|
||
|
||
- (NSString *)extractFolderName:(NSString *)folderName {
|
||
if ([folderName containsString:@"Top Level"] ||
|
||
[folderName isEqual:@"everything"] ||
|
||
[folderName isEqual:@"infrequent"]) {
|
||
folderName = @"";
|
||
}
|
||
if ([folderName containsString:@" - "]) {
|
||
NSInteger folder_loc = [folderName rangeOfString:@" - "
|
||
options:NSBackwardsSearch].location;
|
||
folderName = [folderName substringFromIndex:(folder_loc + 3)];
|
||
}
|
||
|
||
return folderName;
|
||
}
|
||
|
||
- (NSArray *)parentFoldersForFeed:(NSString *)feedId {
|
||
NSMutableArray *folderNames = [[NSMutableArray alloc] init];
|
||
|
||
for (NSString *folderName in self.dictFoldersArray) {
|
||
NSArray *folder = [self.dictFolders objectForKey:folderName];
|
||
if ([folder containsObject:feedId]) {
|
||
[folderNames addObject:[self extractFolderName:folderName]];
|
||
[folderNames addObject:[self extractParentFolderName:folderName]];
|
||
}
|
||
}
|
||
NSMutableArray *uniqueFolderNames = [[NSMutableArray alloc] init];
|
||
for (NSString *folderName in folderNames) {
|
||
if ([uniqueFolderNames containsObject:folderName]) continue;
|
||
if ([folderName containsString:@"Top Level"]) continue;
|
||
if ([folderName length] < 1) continue;
|
||
|
||
[uniqueFolderNames addObject:folderName];
|
||
}
|
||
|
||
return uniqueFolderNames;
|
||
}
|
||
|
||
- (NSString *)feedIdWithoutSearchQuery:(NSString *)feedId {
|
||
NSRange range = [feedId rangeOfString:@"?"];
|
||
|
||
if (range.location == NSNotFound) {
|
||
return feedId;
|
||
} else {
|
||
return [feedId substringToIndex:range.location];
|
||
}
|
||
}
|
||
|
||
- (NSString *)searchQueryForFeedId:(NSString *)feedId {
|
||
NSRange range = [feedId rangeOfString:@"?"];
|
||
|
||
if (range.location == NSNotFound) {
|
||
return nil;
|
||
} else {
|
||
return [feedId substringFromIndex:range.location + range.length];
|
||
}
|
||
}
|
||
|
||
- (NSString *)searchFolderForFeedId:(NSString *)feedId {
|
||
NSString *prefix = @"river:";
|
||
|
||
if (![feedId hasPrefix:prefix]) {
|
||
return nil;
|
||
}
|
||
|
||
return [[self feedIdWithoutSearchQuery:feedId] substringFromIndex:prefix.length];
|
||
}
|
||
|
||
- (NSDictionary *)getFeedWithId:(id)feedId {
|
||
NSString *feedIdStr = [NSString stringWithFormat:@"%@", feedId];
|
||
|
||
return [self getFeed:feedIdStr];
|
||
}
|
||
|
||
- (NSDictionary *)getFeed:(NSString *)feedId {
|
||
feedId = [self feedIdWithoutSearchQuery:feedId];
|
||
|
||
NSDictionary *feed;
|
||
if (storiesCollection.isSocialView ||
|
||
storiesCollection.isSocialRiverView ||
|
||
[feedId startsWith:@"social:"]) {
|
||
feed = [self.dictActiveFeeds objectForKey:feedId];
|
||
// this is to catch when a user is already subscribed
|
||
if (!feed) {
|
||
feed = [self.dictSocialFeeds objectForKey:feedId];
|
||
}
|
||
if (!feed) {
|
||
feed = [self.dictFeeds objectForKey:feedId];
|
||
}
|
||
} else {
|
||
feed = [self.dictFeeds objectForKey:feedId];
|
||
}
|
||
|
||
return feed;
|
||
}
|
||
|
||
- (NSDictionary *)getStory:(NSString *)storyHash {
|
||
for (NSDictionary *story in storiesCollection.activeFeedStories) {
|
||
if ([[story objectForKey:@"story_hash"] isEqualToString:storyHash]) {
|
||
return story;
|
||
}
|
||
}
|
||
return nil;
|
||
}
|
||
|
||
#pragma mark -
|
||
#pragma mark Feed Templates
|
||
|
||
+ (void)fillGradient:(CGRect)r startColor:(UIColor *)startColor endColor:(UIColor *)endColor {
|
||
CGContextRef context = UIGraphicsGetCurrentContext();
|
||
UIGraphicsPushContext(context);
|
||
|
||
CGGradientRef gradient;
|
||
CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
|
||
CGFloat locations[2] = {0.0f, 1.0f};
|
||
CGFloat startRed, startGreen, startBlue, startAlpha;
|
||
CGFloat endRed, endGreen, endBlue, endAlpha;
|
||
|
||
[startColor getRed:&startRed green:&startGreen blue:&startBlue alpha:&startAlpha];
|
||
[endColor getRed:&endRed green:&endGreen blue:&endBlue alpha:&endAlpha];
|
||
|
||
CGFloat components[8] = {
|
||
startRed, startGreen, startBlue, startAlpha,
|
||
endRed, endGreen, endBlue, endAlpha
|
||
};
|
||
gradient = CGGradientCreateWithColorComponents(colorSpace, components, locations, 2);
|
||
CGColorSpaceRelease(colorSpace);
|
||
|
||
CGPoint startPoint = CGPointMake(CGRectGetMinX(r), r.origin.y);
|
||
CGPoint endPoint = CGPointMake(startPoint.x, r.origin.y + r.size.height);
|
||
|
||
CGContextDrawLinearGradient(context, gradient, startPoint, endPoint, 0);
|
||
CGGradientRelease(gradient);
|
||
UIGraphicsPopContext();
|
||
}
|
||
|
||
+ (UIView *)makeSimpleGradientView:(CGRect)rect startColor:(UIColor *)startColor endColor:(UIColor *)endColor {
|
||
UIView *gradientView = [[UIView alloc] initWithFrame:rect];
|
||
|
||
CAGradientLayer *gradient = [CAGradientLayer layer];
|
||
gradient.frame = CGRectMake(0, 0, rect.size.width, rect.size.height);
|
||
gradient.colors = @[(id)[startColor CGColor], (id)[endColor CGColor]];
|
||
|
||
[gradientView.layer addSublayer:gradient];
|
||
|
||
return gradientView;
|
||
}
|
||
|
||
+ (UIColor *)faviconColor:(NSString *)colorString {
|
||
if ([colorString class] == [NSNull class] || !colorString) {
|
||
colorString = @"505050";
|
||
}
|
||
unsigned int color = 0;
|
||
NSScanner *scanner = [NSScanner scannerWithString:colorString];
|
||
[scanner scanHexInt:&color];
|
||
|
||
return UIColorFromFixedRGB(color);
|
||
}
|
||
|
||
+ (UIView *)makeGradientView:(CGRect)rect startColor:(NSString *)start endColor:(NSString *)end borderColor:(NSString *)borderColor {
|
||
UIView *gradientView = [[UIView alloc] initWithFrame:rect];
|
||
|
||
CAGradientLayer *gradient = [CAGradientLayer layer];
|
||
gradient.frame = CGRectMake(0, 1, rect.size.width, rect.size.height-1);
|
||
gradient.opacity = 0.7;
|
||
if ([start class] == [NSNull class] || !start) {
|
||
start = @"505050";
|
||
}
|
||
if ([end class] == [NSNull class] || !end) {
|
||
end = @"303030";
|
||
}
|
||
gradient.colors = [NSArray arrayWithObjects:(id)[[self faviconColor:start] CGColor], (id)[[self faviconColor:end] CGColor], nil];
|
||
|
||
CALayer *whiteBackground = [CALayer layer];
|
||
whiteBackground.frame = CGRectMake(0, 1, rect.size.width, rect.size.height-1);
|
||
whiteBackground.backgroundColor = [UIColorFromRGB(NEWSBLUR_WHITE_COLOR) colorWithAlphaComponent:0.7].CGColor;
|
||
[gradientView.layer addSublayer:whiteBackground];
|
||
|
||
[gradientView.layer addSublayer:gradient];
|
||
|
||
CALayer *topBorder = [CALayer layer];
|
||
topBorder.frame = CGRectMake(0, 1, rect.size.width, 1);
|
||
topBorder.backgroundColor = [[self faviconColor:borderColor] colorWithAlphaComponent:0.7].CGColor;
|
||
topBorder.opacity = 1;
|
||
[gradientView.layer addSublayer:topBorder];
|
||
|
||
CALayer *bottomBorder = [CALayer layer];
|
||
bottomBorder.frame = CGRectMake(0, rect.size.height-1, rect.size.width, 1);
|
||
bottomBorder.backgroundColor = [[self faviconColor:borderColor] colorWithAlphaComponent:0.7].CGColor;
|
||
bottomBorder.opacity = 1;
|
||
[gradientView.layer addSublayer:bottomBorder];
|
||
|
||
return gradientView;
|
||
}
|
||
|
||
- (UIView *)makeFeedTitleGradient:(NSDictionary *)feed withRect:(CGRect)rect {
|
||
UIView *gradientView;
|
||
if (storiesCollection.isRiverView ||
|
||
storiesCollection.isSocialView ||
|
||
storiesCollection.isSocialRiverView ||
|
||
storiesCollection.isSavedView ||
|
||
storiesCollection.isReadView) {
|
||
gradientView = [NewsBlurAppDelegate
|
||
makeGradientView:rect
|
||
startColor:[feed objectForKey:@"favicon_fade"]
|
||
endColor:[feed objectForKey:@"favicon_color"]
|
||
borderColor:[feed objectForKey:@"favicon_border"]];
|
||
|
||
UILabel *titleLabel = [[UILabel alloc] init];
|
||
titleLabel.text = [feed objectForKey:@"feed_title"];
|
||
titleLabel.backgroundColor = [UIColor clearColor];
|
||
titleLabel.textAlignment = NSTextAlignmentLeft;
|
||
titleLabel.lineBreakMode = NSLineBreakByTruncatingTail;
|
||
titleLabel.numberOfLines = 1;
|
||
titleLabel.font = [UIFont fontWithName:@"Helvetica-Bold" size:11.0];
|
||
titleLabel.shadowOffset = CGSizeMake(0, 1);
|
||
if ([[feed objectForKey:@"favicon_text_color"] class] != [NSNull class]) {
|
||
BOOL lightText = [[feed objectForKey:@"favicon_text_color"]
|
||
isEqualToString:@"white"];
|
||
UIColor *fadeColor = [NewsBlurAppDelegate faviconColor:[feed objectForKey:@"favicon_fade"]];
|
||
UIColor *borderColor = [NewsBlurAppDelegate faviconColor:[feed objectForKey:@"favicon_border"]];
|
||
|
||
titleLabel.textColor = lightText ?
|
||
UIColorFromFixedRGB(NEWSBLUR_WHITE_COLOR) :
|
||
UIColorFromFixedRGB(NEWSBLUR_BLACK_COLOR);
|
||
titleLabel.shadowColor = lightText ? borderColor : fadeColor;
|
||
} else {
|
||
titleLabel.textColor = UIColorFromFixedRGB(NEWSBLUR_WHITE_COLOR);
|
||
titleLabel.shadowColor = UIColorFromFixedRGB(NEWSBLUR_BLACK_COLOR);
|
||
}
|
||
titleLabel.frame = CGRectMake(32, 1, rect.size.width-32, 20);
|
||
|
||
NSString *feedIdStr = [NSString stringWithFormat:@"%@", [feed objectForKey:@"id"]];
|
||
UIImage *titleImage = [self getFavicon:feedIdStr];
|
||
UIImageView *titleImageView = [[UIImageView alloc] initWithImage:titleImage];
|
||
titleImageView.frame = CGRectMake(8, 3, 16.0, 16.0);
|
||
[titleLabel addSubview:titleImageView];
|
||
|
||
[gradientView addSubview:titleLabel];
|
||
[gradientView addSubview:titleImageView];
|
||
} else {
|
||
gradientView = [NewsBlurAppDelegate
|
||
makeGradientView:CGRectMake(0, rect.origin.y, rect.size.width, 10)
|
||
// hard coding the 1024 as a hack for window.frame.size.width
|
||
startColor:[feed objectForKey:@"favicon_fade"]
|
||
endColor:[feed objectForKey:@"favicon_color"]
|
||
borderColor:[feed objectForKey:@"favicon_border"]];
|
||
}
|
||
|
||
gradientView.opaque = YES;
|
||
|
||
return gradientView;
|
||
}
|
||
|
||
- (UIView *)makeFeedTitle:(NSDictionary *)feed {
|
||
UILabel *titleLabel = [[UILabel alloc] init];
|
||
if (storiesCollection.isSocialRiverView &&
|
||
[storiesCollection.activeFolder isEqualToString:@"river_blurblogs"]) {
|
||
titleLabel.text = [NSString stringWithFormat:@" All Shared Stories"];
|
||
} else if (storiesCollection.isSocialRiverView &&
|
||
[storiesCollection.activeFolder isEqualToString:@"river_global"]) {
|
||
titleLabel.text = [NSString stringWithFormat:@" Global Shared Stories"];
|
||
} else if (storiesCollection.isRiverView &&
|
||
[storiesCollection.activeFolder isEqualToString:@"everything"]) {
|
||
titleLabel.text = [NSString stringWithFormat:@" All Stories"];
|
||
} else if (storiesCollection.isRiverView &&
|
||
[storiesCollection.activeFolder isEqualToString:@"infrequent"]) {
|
||
titleLabel.text = [NSString stringWithFormat:@" Infrequent Site Stories"];
|
||
} else if (storiesCollection.isSavedView && storiesCollection.activeSavedStoryTag) {
|
||
if (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPhone) {
|
||
titleLabel.text = [NSString stringWithFormat:@" %@", storiesCollection.activeSavedStoryTag];
|
||
} else {
|
||
titleLabel.text = [NSString stringWithFormat:@" Saved Stories - %@", storiesCollection.activeSavedStoryTag];
|
||
}
|
||
} else if ([storiesCollection.activeFolder isEqualToString:@"read_stories"]) {
|
||
titleLabel.text = [NSString stringWithFormat:@" Read Stories"];
|
||
} else if ([storiesCollection.activeFolder isEqualToString:@"saved_stories"]) {
|
||
titleLabel.text = [NSString stringWithFormat:@" Saved Stories"];
|
||
} else if (storiesCollection.isSocialView) {
|
||
titleLabel.text = [NSString stringWithFormat:@" %@", [feed objectForKey:@"feed_title"]];
|
||
} else if (storiesCollection.isRiverView) {
|
||
titleLabel.text = [NSString stringWithFormat:@" %@", storiesCollection.activeFolder];
|
||
} else {
|
||
titleLabel.text = [NSString stringWithFormat:@" %@", [feed objectForKey:@"feed_title"]];
|
||
}
|
||
titleLabel.backgroundColor = [UIColor clearColor];
|
||
titleLabel.textAlignment = NSTextAlignmentLeft;
|
||
titleLabel.font = [UIFont fontWithName:@"Helvetica-Bold" size:15.0];
|
||
titleLabel.textColor = UIColorFromRGB(0x4D4C4A);
|
||
titleLabel.lineBreakMode = NSLineBreakByTruncatingTail;
|
||
titleLabel.numberOfLines = 1;
|
||
titleLabel.shadowColor = UIColorFromRGB(0xF0F0F0);
|
||
titleLabel.shadowOffset = CGSizeMake(0, 1);
|
||
titleLabel.center = CGPointMake(0, -2);
|
||
if (!storiesCollection.isSocialView) {
|
||
titleLabel.center = CGPointMake(28, -2);
|
||
NSString *feedIdStr = [NSString stringWithFormat:@"%@", [feed objectForKey:@"id"]];
|
||
UIImage *titleImage;
|
||
if (storiesCollection.isSocialRiverView &&
|
||
[storiesCollection.activeFolder isEqualToString:@"river_global"]) {
|
||
titleImage = [UIImage imageNamed:@"ak-icon-global.png"];
|
||
} else if (storiesCollection.isSocialRiverView &&
|
||
[storiesCollection.activeFolder isEqualToString:@"river_blurblogs"]) {
|
||
titleImage = [UIImage imageNamed:@"ak-icon-blurblogs.png"];
|
||
} else if (storiesCollection.isRiverView &&
|
||
[storiesCollection.activeFolder isEqualToString:@"everything"]) {
|
||
titleImage = [UIImage imageNamed:@"ak-icon-allstories.png"];
|
||
} else if (storiesCollection.isRiverView &&
|
||
[storiesCollection.activeFolder isEqualToString:@"infrequent"]) {
|
||
titleImage = [UIImage imageNamed:@"ak-icon-allstories.png"];
|
||
} else if (storiesCollection.isSavedView && storiesCollection.activeSavedStoryTag) {
|
||
titleImage = [UIImage imageNamed:@"tag.png"];
|
||
} else if ([storiesCollection.activeFolder isEqualToString:@"read_stories"]) {
|
||
titleImage = [UIImage imageNamed:@"g_icn_folder_read.png"];
|
||
} else if ([storiesCollection.activeFolder isEqualToString:@"saved_stories"]) {
|
||
titleImage = [UIImage imageNamed:@"clock.png"];
|
||
} else if (storiesCollection.isRiverView) {
|
||
titleImage = [UIImage imageNamed:@"g_icn_folder.png"];
|
||
} else {
|
||
titleImage = [self getFavicon:feedIdStr];
|
||
}
|
||
UIImageView *titleImageView = [[UIImageView alloc] initWithImage:titleImage];
|
||
titleImageView.frame = CGRectMake(0.0, 2.0, 16.0, 16.0);
|
||
[titleLabel addSubview:titleImageView];
|
||
}
|
||
[titleLabel sizeToFit];
|
||
|
||
return titleLabel;
|
||
}
|
||
|
||
- (NSString *)folderTitle:(NSString *)folder {
|
||
if ([folder isEqualToString:@"river_blurblogs"]) {
|
||
return @"All Shared Stories";
|
||
} else if ([folder isEqualToString:@"river_global"]) {
|
||
return @"Global Shared Stories";
|
||
} else if ([folder isEqualToString:@"everything"]) {
|
||
return @"All Stories";
|
||
} else if ([folder isEqualToString:@"infrequent"]) {
|
||
return @"Infrequent Site Stories";
|
||
} else if ([folder isEqualToString:@"read_stories"]) {
|
||
return @"Read Stories";
|
||
} else if ([folder isEqualToString:@"saved_searches"]) {
|
||
return @"Saved Searches";
|
||
} else if ([folder isEqualToString:@"saved_stories"]) {
|
||
return @"Saved Stories";
|
||
} else {
|
||
return folder;
|
||
}
|
||
}
|
||
|
||
- (UIImage *)folderIcon:(NSString *)folder {
|
||
if ([folder isEqualToString:@"river_global"]) {
|
||
return [UIImage imageNamed:@"ak-icon-global.png"];
|
||
} else if ([folder isEqualToString:@"river_blurblogs"]) {
|
||
return [UIImage imageNamed:@"ak-icon-blurblogs.png"];
|
||
} else if ([folder isEqualToString:@"everything"]) {
|
||
return [UIImage imageNamed:@"ak-icon-allstories.png"];
|
||
} else if ([folder isEqualToString:@"infrequent"]) {
|
||
return [UIImage imageNamed:@"ak-icon-allstories.png"];
|
||
} else if ([folder isEqualToString:@"read_stories"]) {
|
||
return [UIImage imageNamed:@"g_icn_folder_read.png"];
|
||
} else if ([folder isEqualToString:@"saved_searches"]) {
|
||
return [UIImage imageNamed:@"g_icn_search.png"];
|
||
} else if ([folder isEqualToString:@"saved_stories"]) {
|
||
return [UIImage imageNamed:@"clock.png"];
|
||
} else {
|
||
return [UIImage imageNamed:@"g_icn_folder.png"];
|
||
}
|
||
}
|
||
|
||
- (void)saveFavicon:(UIImage *)image feedId:(NSString *)filename {
|
||
if (image && filename && ![image isKindOfClass:[NSNull class]] &&
|
||
[filename class] != [NSNull class]) {
|
||
[self.cachedFavicons setObject:image forKey:filename];
|
||
}
|
||
}
|
||
|
||
- (UIImage *)getFavicon:(NSString *)filename {
|
||
return [self getFavicon:filename isSocial:NO];
|
||
}
|
||
|
||
- (UIImage *)getFavicon:(NSString *)filename isSocial:(BOOL)isSocial {
|
||
return [self getFavicon:filename isSocial:isSocial isSaved:NO];
|
||
}
|
||
|
||
- (UIImage *)getFavicon:(NSString *)filename isSocial:(BOOL)isSocial isSaved:(BOOL)isSaved {
|
||
UIImage *image = [self.cachedFavicons objectForKey:filename];
|
||
|
||
if (image) {
|
||
return image;
|
||
} else {
|
||
if (isSocial) {
|
||
// return [UIImage imageNamed:@"user_light.png"];
|
||
return nil;
|
||
} else if (isSaved) {
|
||
return [UIImage imageNamed:@"tag.png"];
|
||
} else {
|
||
return [UIImage imageNamed:@"world.png"];
|
||
}
|
||
}
|
||
}
|
||
|
||
#pragma mark -
|
||
#pragma mark Classifiers
|
||
|
||
- (void)failedClassifierSave:(NSURLSessionDataTask *)task {
|
||
BaseViewController *view;
|
||
if (self.trainerViewController.isViewLoaded && self.trainerViewController.view.window) {
|
||
view = self.trainerViewController;
|
||
} else {
|
||
view = self.storyPageControl.currentPage;
|
||
}
|
||
|
||
NSHTTPURLResponse *response = (NSHTTPURLResponse *)task.response;
|
||
if (response.statusCode == 503) {
|
||
[view informError:@"In maintenance mode"];
|
||
} else {
|
||
[view informError:@"The server barfed!"];
|
||
}
|
||
}
|
||
|
||
- (void)toggleAuthorClassifier:(NSString *)author feedId:(NSString *)feedId {
|
||
int authorScore = [[[[storiesCollection.activeClassifiers objectForKey:feedId]
|
||
objectForKey:@"authors"]
|
||
objectForKey:author] intValue];
|
||
if (authorScore > 0) {
|
||
authorScore = -1;
|
||
} else if (authorScore < 0) {
|
||
authorScore = 0;
|
||
} else {
|
||
authorScore = 1;
|
||
}
|
||
NSMutableDictionary *feedClassifiers = [[storiesCollection.activeClassifiers objectForKey:feedId]
|
||
mutableCopy];
|
||
if (!feedClassifiers) feedClassifiers = [NSMutableDictionary dictionary];
|
||
NSMutableDictionary *authors = [[feedClassifiers objectForKey:@"authors"] mutableCopy];
|
||
if (!authors) authors = [NSMutableDictionary dictionary];
|
||
[authors setObject:[NSNumber numberWithInt:authorScore] forKey:author];
|
||
[feedClassifiers setObject:authors forKey:@"authors"];
|
||
[storiesCollection.activeClassifiers setObject:feedClassifiers forKey:feedId];
|
||
[self.storyPageControl refreshHeaders];
|
||
[self.trainerViewController refresh];
|
||
|
||
NSString *urlString = [NSString stringWithFormat:@"%@/classifier/save",
|
||
self.url];
|
||
NSMutableDictionary *params = [NSMutableDictionary dictionary];
|
||
[params setObject:author
|
||
forKey:authorScore >= 1 ? @"like_author" :
|
||
authorScore <= -1 ? @"dislike_author" :
|
||
@"remove_like_author"];
|
||
[params setObject:feedId forKey:@"feed_id"];
|
||
|
||
[self POST:urlString parameters:params success:^(NSURLSessionDataTask * _Nonnull task, id _Nullable responseObject) {
|
||
[self.feedsViewController refreshFeedList:feedId];
|
||
} failure:^(NSURLSessionDataTask * _Nullable task, NSError * _Nonnull error) {
|
||
[self failedClassifierSave:task];
|
||
}];
|
||
|
||
[self recalculateIntelligenceScores:feedId];
|
||
[self.feedDetailViewController.storyTitlesTable reloadData];
|
||
}
|
||
|
||
- (void)toggleTagClassifier:(NSString *)tag feedId:(NSString *)feedId {
|
||
NSLog(@"toggleTagClassifier: %@", tag);
|
||
int tagScore = [[[[storiesCollection.activeClassifiers objectForKey:feedId]
|
||
objectForKey:@"tags"]
|
||
objectForKey:tag] intValue];
|
||
|
||
if (tagScore > 0) {
|
||
tagScore = -1;
|
||
} else if (tagScore < 0) {
|
||
tagScore = 0;
|
||
} else {
|
||
tagScore = 1;
|
||
}
|
||
|
||
NSMutableDictionary *feedClassifiers = [[storiesCollection.activeClassifiers objectForKey:feedId]
|
||
mutableCopy];
|
||
if (!feedClassifiers) feedClassifiers = [NSMutableDictionary dictionary];
|
||
NSMutableDictionary *tags = [[feedClassifiers objectForKey:@"tags"] mutableCopy];
|
||
if (!tags) tags = [NSMutableDictionary dictionary];
|
||
[tags setObject:[NSNumber numberWithInt:tagScore] forKey:tag];
|
||
[feedClassifiers setObject:tags forKey:@"tags"];
|
||
[storiesCollection.activeClassifiers setObject:feedClassifiers forKey:feedId];
|
||
[self.storyPageControl refreshHeaders];
|
||
[self.trainerViewController refresh];
|
||
|
||
NSString *urlString = [NSString stringWithFormat:@"%@/classifier/save",
|
||
self.url];
|
||
NSMutableDictionary *params = [NSMutableDictionary dictionary];
|
||
[params setObject:tag
|
||
forKey:tagScore >= 1 ? @"like_tag" :
|
||
tagScore <= -1 ? @"dislike_tag" :
|
||
@"remove_like_tag"];
|
||
[params setObject:feedId forKey:@"feed_id"];
|
||
|
||
[self POST:urlString parameters:params success:^(NSURLSessionDataTask * _Nonnull task, id _Nullable responseObject) {
|
||
[self.feedsViewController refreshFeedList:feedId];
|
||
} failure:^(NSURLSessionDataTask * _Nullable task, NSError * _Nonnull error) {
|
||
[self failedClassifierSave:task];
|
||
}];
|
||
|
||
[self recalculateIntelligenceScores:feedId];
|
||
[self.feedDetailViewController.storyTitlesTable reloadData];
|
||
}
|
||
|
||
- (void)toggleTitleClassifier:(NSString *)title feedId:(NSString *)feedId score:(NSInteger)score {
|
||
NSLog(@"toggle Title: %@ (%@) / %ld", title, feedId, (long)score);
|
||
NSInteger titleScore = [[[[storiesCollection.activeClassifiers objectForKey:feedId]
|
||
objectForKey:@"titles"]
|
||
objectForKey:title] intValue];
|
||
|
||
if (score) {
|
||
titleScore = score;
|
||
} else {
|
||
if (titleScore > 0) {
|
||
titleScore = -1;
|
||
} else if (titleScore < 0) {
|
||
titleScore = 0;
|
||
} else {
|
||
titleScore = 1;
|
||
}
|
||
}
|
||
|
||
NSMutableDictionary *feedClassifiers = [[storiesCollection.activeClassifiers objectForKey:feedId]
|
||
mutableCopy];
|
||
if (!feedClassifiers) feedClassifiers = [NSMutableDictionary dictionary];
|
||
NSMutableDictionary *titles = [[feedClassifiers objectForKey:@"titles"] mutableCopy];
|
||
if (!titles) titles = [NSMutableDictionary dictionary];
|
||
[titles setObject:[NSNumber numberWithInteger:titleScore] forKey:title];
|
||
[feedClassifiers setObject:titles forKey:@"titles"];
|
||
[storiesCollection.activeClassifiers setObject:feedClassifiers forKey:feedId];
|
||
[self.storyPageControl refreshHeaders];
|
||
[self.trainerViewController refresh];
|
||
|
||
NSString *urlString = [NSString stringWithFormat:@"%@/classifier/save",
|
||
self.url];
|
||
NSMutableDictionary *params = [NSMutableDictionary dictionary];
|
||
[params setObject:title
|
||
forKey:titleScore >= 1 ? @"like_title" :
|
||
titleScore <= -1 ? @"dislike_title" :
|
||
@"remove_like_title"];
|
||
[params setObject:feedId forKey:@"feed_id"];
|
||
|
||
[self POST:urlString parameters:params success:^(NSURLSessionDataTask * _Nonnull task, id _Nullable responseObject) {
|
||
[self.feedsViewController refreshFeedList:feedId];
|
||
} failure:^(NSURLSessionDataTask * _Nullable task, NSError * _Nonnull error) {
|
||
[self failedClassifierSave:task];
|
||
}];
|
||
|
||
[self recalculateIntelligenceScores:feedId];
|
||
[self.feedDetailViewController.storyTitlesTable reloadData];
|
||
}
|
||
|
||
- (void)toggleFeedClassifier:(NSString *)feedId {
|
||
int feedScore = [[[[storiesCollection.activeClassifiers objectForKey:feedId]
|
||
objectForKey:@"feeds"]
|
||
objectForKey:feedId] intValue];
|
||
|
||
if (feedScore > 0) {
|
||
feedScore = -1;
|
||
} else if (feedScore < 0) {
|
||
feedScore = 0;
|
||
} else {
|
||
feedScore = 1;
|
||
}
|
||
|
||
NSMutableDictionary *feedClassifiers = [[storiesCollection.activeClassifiers objectForKey:feedId]
|
||
mutableCopy];
|
||
if (!feedClassifiers) feedClassifiers = [NSMutableDictionary dictionary];
|
||
NSMutableDictionary *feeds = [[feedClassifiers objectForKey:@"feeds"] mutableCopy];
|
||
[feeds setObject:[NSNumber numberWithInt:feedScore] forKey:feedId];
|
||
[feedClassifiers setObject:feeds forKey:@"feeds"];
|
||
[storiesCollection.activeClassifiers setObject:feedClassifiers forKey:feedId];
|
||
[self.storyPageControl refreshHeaders];
|
||
[self.trainerViewController refresh];
|
||
|
||
NSString *urlString = [NSString stringWithFormat:@"%@/classifier/save",
|
||
self.url];
|
||
NSMutableDictionary *params = [NSMutableDictionary dictionary];
|
||
[params setObject:feedId
|
||
forKey:feedScore >= 1 ? @"like_feed" :
|
||
feedScore <= -1 ? @"dislike_feed" :
|
||
@"remove_like_feed"];
|
||
[params setObject:feedId forKey:@"feed_id"];
|
||
|
||
[self POST:urlString parameters:params success:^(NSURLSessionDataTask * _Nonnull task, id _Nullable responseObject) {
|
||
[self.feedsViewController refreshFeedList:feedId];
|
||
} failure:^(NSURLSessionDataTask * _Nullable task, NSError * _Nonnull error) {
|
||
[self failedRequest:task.response];
|
||
}];
|
||
|
||
[self recalculateIntelligenceScores:feedId];
|
||
[self.feedDetailViewController.storyTitlesTable reloadData];
|
||
}
|
||
|
||
- (void)failedRequest:(NSURLResponse *)response {
|
||
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *)response;
|
||
BaseViewController *view;
|
||
if (self.trainerViewController.isViewLoaded && self.trainerViewController.view.window) {
|
||
view = self.trainerViewController;
|
||
} else {
|
||
view = self.storyPageControl.currentPage;
|
||
}
|
||
if (httpResponse.statusCode == 503) {
|
||
return [view informError:@"In maintenance mode"];
|
||
} else if (httpResponse.statusCode != 200) {
|
||
return [view informError:@"The server barfed!"];
|
||
}
|
||
}
|
||
|
||
#pragma mark -
|
||
#pragma mark Storing Stories for Offline
|
||
|
||
// Returns the URL to the application's Documents directory.
|
||
- (NSURL *)applicationDocumentsDirectory
|
||
{
|
||
NSLog(@" ---> DB dir: %@",[[[NSFileManager defaultManager] URLsForDirectory:NSDocumentDirectory inDomains:NSUserDomainMask] lastObject]);
|
||
|
||
return [[[NSFileManager defaultManager] URLsForDirectory:NSDocumentDirectory inDomains:NSUserDomainMask] lastObject];
|
||
}
|
||
|
||
- (NSInteger)databaseSchemaVersion:(FMDatabase *)db {
|
||
int version = 0;
|
||
FMResultSet *resultSet = [db executeQuery:@"PRAGMA user_version"];
|
||
if ([resultSet next]) {
|
||
version = [resultSet intForColumnIndex:0];
|
||
}
|
||
[resultSet close];
|
||
return version;
|
||
}
|
||
|
||
- (void)createDatabaseConnection {
|
||
NSError *error;
|
||
|
||
// Remove the deletion of old sqlite dbs past version 3.1, once everybody's
|
||
// upgraded and removed the old files.
|
||
NSFileManager *fileManager = [[NSFileManager alloc] init];
|
||
NSArray *documentPaths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
|
||
NSString *oldDBPath = [documentPaths objectAtIndex:0];
|
||
NSArray *directoryContents = [fileManager contentsOfDirectoryAtPath:oldDBPath error:&error];
|
||
int removed = 0;
|
||
|
||
if (error == nil) {
|
||
for (NSString *path in directoryContents) {
|
||
NSString *fullPath = [oldDBPath stringByAppendingPathComponent:path];
|
||
if ([fullPath hasSuffix:@".sqlite"]) {
|
||
[fileManager removeItemAtPath:fullPath error:&error];
|
||
removed++;
|
||
}
|
||
}
|
||
}
|
||
if (removed) {
|
||
NSLog(@"Deleted %d sql dbs.", removed);
|
||
}
|
||
|
||
NSArray *cachePaths = NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES);
|
||
NSString *dbPath = [cachePaths objectAtIndex:0];
|
||
NSString *dbName = [NSString stringWithFormat:@"%@.sqlite", self.host];
|
||
NSString *path = [dbPath stringByAppendingPathComponent:dbName];
|
||
[self applicationDocumentsDirectory];
|
||
|
||
database = [FMDatabaseQueue databaseQueueWithPath:path];
|
||
[database inDatabase:^(FMDatabase *db) {
|
||
// db.traceExecution = YES;
|
||
[self setupDatabase:db force:NO];
|
||
}];
|
||
}
|
||
|
||
- (void)setupDatabase:(FMDatabase *)db force:(BOOL)force {
|
||
NSUInteger databaseVersion = [self databaseSchemaVersion:db];
|
||
|
||
if (databaseVersion < CURRENT_DB_VERSION || force) {
|
||
// FMDB cannot execute this query because FMDB tries to use prepared statements
|
||
[db closeOpenResultSets];
|
||
|
||
// Perform just the needed updates (in the future, if any of these table schemas change, move their drop statement to a new block below)
|
||
if (databaseVersion < 35) {
|
||
[db executeUpdate:@"drop table if exists `stories`"];
|
||
[db executeUpdate:@"drop table if exists `unread_hashes`"];
|
||
[db executeUpdate:@"drop table if exists `accounts`"];
|
||
[db executeUpdate:@"drop table if exists `unread_counts`"];
|
||
[db executeUpdate:@"drop table if exists `cached_images`"];
|
||
[db executeUpdate:@"drop table if exists `users`"];
|
||
// [db executeUpdate:@"drop table if exists `queued_read_hashes`"]; // Nope, don't clear this.
|
||
// [db executeUpdate:@"drop table if exists `queued_saved_hashes`"]; // Nope, don't clear this.
|
||
|
||
NSFileManager *fileManager = [NSFileManager defaultManager];
|
||
NSArray *paths = NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES);
|
||
NSString *cacheDirectory = [[paths objectAtIndex:0] stringByAppendingPathComponent:@"story_images"];
|
||
NSError *error = nil;
|
||
BOOL success = [fileManager removeItemAtPath:cacheDirectory error:&error];
|
||
if (!success || error) {
|
||
// something went wrong
|
||
}
|
||
}
|
||
|
||
if (databaseVersion < 36) {
|
||
[db executeUpdate:@"drop table if exists `queued_saved_hashes`"];
|
||
}
|
||
|
||
if (databaseVersion < 37) {
|
||
[db executeUpdate:@"drop table if exists `cached_text`"];
|
||
}
|
||
|
||
NSLog(@"Dropped db: %@", [db lastErrorMessage]);
|
||
sqlite3_exec(db.sqliteHandle, [[NSString stringWithFormat:@"PRAGMA user_version = %d", CURRENT_DB_VERSION] UTF8String], NULL, NULL, NULL);
|
||
}
|
||
NSString *createAccountsTable = [NSString stringWithFormat:@"create table if not exists accounts "
|
||
"("
|
||
" username varchar(36),"
|
||
" download_date date,"
|
||
" feeds_json text,"
|
||
" UNIQUE(username) ON CONFLICT REPLACE"
|
||
")"];
|
||
[db executeUpdate:createAccountsTable];
|
||
|
||
NSString *createCountsTable = [NSString stringWithFormat:@"create table if not exists unread_counts "
|
||
"("
|
||
" feed_id varchar(20),"
|
||
" ps number,"
|
||
" nt number,"
|
||
" ng number,"
|
||
" UNIQUE(feed_id) ON CONFLICT REPLACE"
|
||
")"];
|
||
[db executeUpdate:createCountsTable];
|
||
|
||
NSString *createStoryTable = [NSString stringWithFormat:@"create table if not exists stories "
|
||
"("
|
||
" story_feed_id varchar(20),"
|
||
" story_hash varchar(24),"
|
||
" story_timestamp number,"
|
||
" story_json text,"
|
||
" scroll number,"
|
||
" UNIQUE(story_hash) ON CONFLICT REPLACE"
|
||
")"];
|
||
[db executeUpdate:createStoryTable];
|
||
NSString *indexStoriesFeed = @"CREATE INDEX IF NOT EXISTS stories_story_feed_id ON stories (story_feed_id)";
|
||
[db executeUpdate:indexStoriesFeed];
|
||
|
||
|
||
NSString *createStoryScrollsTable = [NSString stringWithFormat:@"create table if not exists story_scrolls "
|
||
"("
|
||
" story_feed_id varchar(20),"
|
||
" story_hash varchar(24),"
|
||
" story_timestamp number,"
|
||
" scroll number,"
|
||
" UNIQUE(story_hash) ON CONFLICT REPLACE"
|
||
")"];
|
||
[db executeUpdate:createStoryScrollsTable];
|
||
NSString *indexStoriesHash = @"CREATE INDEX IF NOT EXISTS story_scrolls_story_hash ON story_scrolls (story_hash)";
|
||
[db executeUpdate:indexStoriesHash];
|
||
|
||
NSString *createUnreadHashTable = [NSString stringWithFormat:@"create table if not exists unread_hashes "
|
||
"("
|
||
" story_feed_id varchar(20),"
|
||
" story_hash varchar(24),"
|
||
" story_timestamp number,"
|
||
" UNIQUE(story_hash) ON CONFLICT IGNORE"
|
||
")"];
|
||
[db executeUpdate:createUnreadHashTable];
|
||
NSString *indexUnreadHashes = @"CREATE INDEX IF NOT EXISTS unread_hashes_story_feed_id ON unread_hashes (story_feed_id)";
|
||
[db executeUpdate:indexUnreadHashes];
|
||
NSString *indexUnreadTimestamp = @"CREATE INDEX IF NOT EXISTS unread_hashes_timestamp ON stories (story_timestamp)";
|
||
[db executeUpdate:indexUnreadTimestamp];
|
||
|
||
NSString *createReadTable = [NSString stringWithFormat:@"create table if not exists queued_read_hashes "
|
||
"("
|
||
" story_feed_id varchar(20),"
|
||
" story_hash varchar(24),"
|
||
" UNIQUE(story_hash) ON CONFLICT IGNORE"
|
||
")"];
|
||
[db executeUpdate:createReadTable];
|
||
|
||
NSString *createSavedTable = [NSString stringWithFormat:@"create table if not exists queued_saved_hashes "
|
||
"("
|
||
" story_feed_id varchar(20),"
|
||
" story_hash varchar(24),"
|
||
" saved boolean,"
|
||
" info_json text,"
|
||
" UNIQUE(story_hash) ON CONFLICT IGNORE"
|
||
")"];
|
||
[db executeUpdate:createSavedTable];
|
||
|
||
NSString *createTextTable = [NSString stringWithFormat:@"create table if not exists cached_text "
|
||
"("
|
||
" story_feed_id varchar(20),"
|
||
" story_hash varchar(24),"
|
||
" story_timestamp number,"
|
||
" text_json text"
|
||
")"];
|
||
[db executeUpdate:createTextTable];
|
||
NSString *indexTextFeedId = @"CREATE INDEX IF NOT EXISTS cached_text_story_feed_id ON cached_text (story_feed_id)";
|
||
[db executeUpdate:indexTextFeedId];
|
||
NSString *indexTextStoryHash = @"CREATE INDEX IF NOT EXISTS cached_text_story_hash ON cached_text (story_hash)";
|
||
[db executeUpdate:indexTextStoryHash];
|
||
|
||
NSString *createImagesTable = [NSString stringWithFormat:@"create table if not exists cached_images "
|
||
"("
|
||
" story_feed_id varchar(20),"
|
||
" story_hash varchar(24),"
|
||
" image_url varchar(1024),"
|
||
" image_cached boolean,"
|
||
" failed boolean"
|
||
")"];
|
||
[db executeUpdate:createImagesTable];
|
||
NSString *indexImagesFeedId = @"CREATE INDEX IF NOT EXISTS cached_images_story_feed_id ON cached_images (story_feed_id)";
|
||
[db executeUpdate:indexImagesFeedId];
|
||
NSString *indexImagesStoryHash = @"CREATE INDEX IF NOT EXISTS cached_images_story_hash ON cached_images (story_hash)";
|
||
[db executeUpdate:indexImagesStoryHash];
|
||
|
||
|
||
NSString *createUsersTable = [NSString stringWithFormat:@"create table if not exists users "
|
||
"("
|
||
" user_id number,"
|
||
" username varchar(64),"
|
||
" location varchar(128),"
|
||
" image_url varchar(1024),"
|
||
" image_cached boolean,"
|
||
" user_json text,"
|
||
" UNIQUE(user_id) ON CONFLICT REPLACE"
|
||
")"];
|
||
[db executeUpdate:createUsersTable];
|
||
NSString *indexUsersUserId = @"CREATE INDEX IF NOT EXISTS users_user_id ON users (user_id)";
|
||
[db executeUpdate:indexUsersUserId];
|
||
|
||
NSError *error;
|
||
NSArray *paths = NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES);
|
||
NSString *storyImagesDirectory = [[paths objectAtIndex:0] stringByAppendingPathComponent:@"story_images"];
|
||
if (![[NSFileManager defaultManager] fileExistsAtPath:storyImagesDirectory]) {
|
||
[[NSFileManager defaultManager] createDirectoryAtPath:storyImagesDirectory
|
||
withIntermediateDirectories:NO
|
||
attributes:nil
|
||
error:&error];
|
||
}
|
||
|
||
// NSLog(@"Create db %d: %@", [db lastErrorCode], [db lastErrorMessage]);
|
||
}
|
||
|
||
- (void)cancelOfflineQueue {
|
||
if (offlineQueue) {
|
||
[offlineQueue cancelAllOperations];
|
||
}
|
||
if (offlineCleaningQueue) {
|
||
[offlineCleaningQueue cancelAllOperations];
|
||
}
|
||
}
|
||
|
||
- (void)startOfflineQueue {
|
||
if (!offlineQueue) {
|
||
offlineQueue = [NSOperationQueue new];
|
||
}
|
||
offlineQueue.name = @"Offline Queue";
|
||
// NSLog(@"Operation queue: %lu", (unsigned long)offlineQueue.operationCount);
|
||
[offlineQueue cancelAllOperations];
|
||
[offlineQueue setMaxConcurrentOperationCount:1];
|
||
OfflineSyncUnreads *operationSyncUnreads = [[OfflineSyncUnreads alloc] init];
|
||
|
||
[offlineQueue addOperation:operationSyncUnreads];
|
||
}
|
||
|
||
- (void)startOfflineFetchStories {
|
||
OfflineFetchStories *operationFetchStories = [[OfflineFetchStories alloc] init];
|
||
|
||
[offlineQueue addOperation:operationFetchStories];
|
||
|
||
// NSLog(@"Done start offline fetch stories");
|
||
}
|
||
|
||
- (void)startOfflineFetchText {
|
||
OfflineFetchText *operationFetchText = [[OfflineFetchText alloc] init];
|
||
|
||
[offlineQueue addOperation:operationFetchText];
|
||
}
|
||
|
||
- (void)startOfflineFetchImages {
|
||
OfflineFetchImages *operationFetchImages = [[OfflineFetchImages alloc] init];
|
||
|
||
[offlineQueue addOperation:operationFetchImages];
|
||
}
|
||
|
||
- (BOOL)isReachableForOffline {
|
||
Reachability *reachability = [Reachability reachabilityForInternetConnection];
|
||
NetworkStatus remoteHostStatus = [reachability currentReachabilityStatus];
|
||
|
||
NSString *connection = [[NSUserDefaults standardUserDefaults]
|
||
stringForKey:@"offline_download_connection"];
|
||
|
||
// NSLog(@"Reachable via: %d / %d", remoteHostStatus == ReachableViaWWAN, remoteHostStatus == ReachableViaWiFi);
|
||
if ([connection isEqualToString:@"wifi"] && remoteHostStatus != ReachableViaWiFi) {
|
||
return NO;
|
||
}
|
||
|
||
return YES;
|
||
}
|
||
|
||
- (void)storeUserProfiles:(NSArray *)userProfiles {
|
||
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,
|
||
(unsigned long)NULL), ^(void) {
|
||
[self.database inTransaction:^(FMDatabase *db, BOOL *rollback) {
|
||
for (NSDictionary *user in userProfiles) {
|
||
[db executeUpdate:@"INSERT INTO users "
|
||
"(user_id, username, location, image_url, user_json) VALUES "
|
||
"(?, ?, ?, ?, ?)",
|
||
[user objectForKey:@"user_id"],
|
||
[user objectForKey:@"username"],
|
||
[user objectForKey:@"location"],
|
||
[user objectForKey:@"photo_url"],
|
||
[user JSONRepresentation]
|
||
];
|
||
}
|
||
}];
|
||
});
|
||
}
|
||
|
||
- (void)markScrollPosition:(NSInteger)position inStory:(NSDictionary *)story {
|
||
if (position < 0) return;
|
||
__block NSNumber *positionNum = @(position);
|
||
__block NSDictionary *storyDict = story;
|
||
|
||
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW,
|
||
(unsigned long)NULL), ^(void) {
|
||
[self.database inDatabase:^(FMDatabase *db) {
|
||
NSLog(@"Saving scroll %ld in %@-%@", (long)[positionNum integerValue], [storyDict objectForKey:@"story_hash"], [storyDict objectForKey:@"story_title"]);
|
||
[db executeUpdate:@"INSERT INTO story_scrolls (story_feed_id, story_hash, story_timestamp, scroll) VALUES (?, ?, ?, ?)",
|
||
[storyDict objectForKey:@"story_feed_id"],
|
||
[storyDict objectForKey:@"story_hash"],
|
||
[storyDict objectForKey:@"story_timestamp"],
|
||
positionNum];
|
||
}];
|
||
});
|
||
}
|
||
|
||
- (void)queueReadStories:(NSDictionary *)feedsStories {
|
||
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,
|
||
(unsigned long)NULL), ^(void) {
|
||
[self.database inTransaction:^(FMDatabase *db, BOOL *rollback) {
|
||
for (NSString *feedIdStr in [feedsStories allKeys]) {
|
||
for (NSString *storyHash in [feedsStories objectForKey:feedIdStr]) {
|
||
[db executeUpdate:@"INSERT INTO queued_read_hashes "
|
||
"(story_feed_id, story_hash) VALUES "
|
||
"(?, ?)", feedIdStr, storyHash];
|
||
}
|
||
}
|
||
}];
|
||
});
|
||
self.hasQueuedReadStories = YES;
|
||
}
|
||
|
||
- (BOOL)dequeueReadStoryHash:(NSString *)storyHash inFeed:(NSString *)storyFeedId {
|
||
__block BOOL storyQueued = NO;
|
||
|
||
[self.database inDatabase:^(FMDatabase *db) {
|
||
FMResultSet *stories = [db executeQuery:@"SELECT * FROM queued_read_hashes "
|
||
"WHERE story_hash = ? AND story_feed_id = ? LIMIT 1",
|
||
storyHash, storyFeedId];
|
||
while ([stories next]) {
|
||
storyQueued = YES;
|
||
break;
|
||
}
|
||
[stories close];
|
||
if (storyQueued) {
|
||
[db executeUpdate:@"DELETE FROM queued_read_hashes "
|
||
"WHERE story_hash = ? AND story_feed_id = ?",
|
||
storyHash, storyFeedId];
|
||
}
|
||
}];
|
||
|
||
return storyQueued;
|
||
}
|
||
|
||
- (void)flushQueuedReadStories:(BOOL)forceCheck withCallback:(void(^)(void))callback {
|
||
if (self.feedsViewController.isOffline) {
|
||
if (callback) callback();
|
||
return;
|
||
}
|
||
|
||
if (self.hasQueuedReadStories || forceCheck) {
|
||
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW,
|
||
(unsigned long)NULL), ^(void) {
|
||
[self.database inTransaction:^(FMDatabase *db, BOOL *rollback) {
|
||
NSMutableDictionary *hashes = [NSMutableDictionary dictionary];
|
||
FMResultSet *stories = [db executeQuery:@"SELECT * FROM queued_read_hashes"];
|
||
while ([stories next]) {
|
||
NSString *storyFeedId = [NSString stringWithFormat:@"%@", [stories objectForColumnName:@"story_feed_id"]];
|
||
NSString *storyHash = [stories objectForColumnName:@"story_hash"];
|
||
if (![hashes objectForKey:storyFeedId]) {
|
||
[hashes setObject:[NSMutableArray array] forKey:storyFeedId];
|
||
}
|
||
[[hashes objectForKey:storyFeedId] addObject:storyHash];
|
||
}
|
||
|
||
if ([[hashes allKeys] count]) {
|
||
self.hasQueuedReadStories = NO;
|
||
[self syncQueuedReadStories:db withStories:hashes withCallback:callback];
|
||
} else {
|
||
if (callback) callback();
|
||
}
|
||
[stories close];
|
||
}];
|
||
});
|
||
} else {
|
||
if (callback) callback();
|
||
}
|
||
}
|
||
|
||
- (void)syncQueuedReadStories:(FMDatabase *)db withStories:(NSDictionary *)hashes withCallback:(void(^)(void))callback {
|
||
NSString *urlString = [NSString stringWithFormat:@"%@/reader/mark_feed_stories_as_read",
|
||
self.url];
|
||
NSMutableArray *completedHashes = [NSMutableArray array];
|
||
for (NSArray *storyHashes in [hashes allValues]) {
|
||
[completedHashes addObjectsFromArray:storyHashes];
|
||
}
|
||
NSLog(@"Marking %lu queued read stories as read...", (unsigned long)[completedHashes count]);
|
||
NSString *completedHashesStr = [completedHashes componentsJoinedByString:@"\",\""];
|
||
NSMutableDictionary *params = [NSMutableDictionary dictionary];
|
||
[params setObject:[hashes JSONRepresentation] forKey:@"feeds_stories"];
|
||
|
||
[self POST:urlString parameters:params success:^(NSURLSessionDataTask * _Nonnull task, id _Nullable responseObject) {
|
||
NSLog(@"Completed clearing %@ hashes", completedHashesStr);
|
||
[db executeUpdate:[NSString stringWithFormat:@"DELETE FROM queued_read_hashes "
|
||
"WHERE story_hash in (\"%@\")", completedHashesStr]];
|
||
[self pruneQueuedReadHashes];
|
||
if (callback) callback();
|
||
} failure:^(NSURLSessionDataTask * _Nullable task, NSError * _Nonnull error) {
|
||
NSLog(@"Failed mark read queued.");
|
||
self.hasQueuedReadStories = YES;
|
||
[self pruneQueuedReadHashes];
|
||
if (callback) callback();
|
||
}];
|
||
}
|
||
|
||
- (void)pruneQueuedReadHashes {
|
||
[self.database inTransaction:^(FMDatabase *db, BOOL *rollback) {
|
||
NSString *unreadSql = [NSString stringWithFormat:@"SELECT qrh.story_hash FROM queued_read_hashes qrh "
|
||
"INNER JOIN unread_hashes uh ON qrh.story_hash = uh.story_hash"];
|
||
FMResultSet *cursor = [db executeQuery:unreadSql];
|
||
while ([cursor next]) {
|
||
NSLog(@"Story: %@", [cursor objectForColumnName:@"story_hash"]);
|
||
}
|
||
// NSLog(@"Found %lu stories queued to be read but already read", (unsigned long)[[cursor.resultDictionary allKeys] count]);
|
||
NSString *deleteSql = [NSString stringWithFormat:@"DELETE FROM queued_read_hashes "
|
||
"WHERE story_hash not in (%@)", unreadSql];
|
||
[db executeUpdate:deleteSql];
|
||
}];
|
||
}
|
||
|
||
|
||
- (void)queueSavedStory:(NSDictionary *)story {
|
||
NSString *storyHash = [story objectForKey:@"story_hash"];
|
||
NSString *storyFeedId = [story objectForKey:@"story_feed_id"];
|
||
|
||
if ([self dequeueSavedStoryHash:storyHash inFeed:storyFeedId]) {
|
||
return;
|
||
}
|
||
|
||
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,
|
||
(unsigned long)NULL), ^(void) {
|
||
[self.database inTransaction:^(FMDatabase *db, BOOL *rollback) {
|
||
BOOL isSaved = [[story objectForKey:@"starred"] boolValue];
|
||
NSArray *userTags = [[story objectForKey:@"user_tags"] copy];
|
||
NSDictionary *info = @{@"user_tags" : userTags}; // A dictionary to enable easily adding future properties (highlights?)
|
||
|
||
[db executeUpdate:@"INSERT INTO queued_saved_hashes "
|
||
"(story_feed_id, story_hash, saved, info_json) VALUES "
|
||
"(?, ?, ?, ?)", storyFeedId, storyHash, @(isSaved), info.JSONRepresentation];
|
||
}];
|
||
});
|
||
self.hasQueuedSavedStories = YES;
|
||
}
|
||
|
||
- (BOOL)dequeueSavedStoryHash:(NSString *)storyHash inFeed:(NSString *)storyFeedId {
|
||
__block BOOL storyQueued = NO;
|
||
|
||
[self.database inDatabase:^(FMDatabase *db) {
|
||
FMResultSet *stories = [db executeQuery:@"SELECT * FROM queued_saved_hashes "
|
||
"WHERE story_hash = ? AND story_feed_id = ? LIMIT 1",
|
||
storyHash, storyFeedId];
|
||
while ([stories next]) {
|
||
storyQueued = YES;
|
||
break;
|
||
}
|
||
[stories close];
|
||
if (storyQueued) {
|
||
[db executeUpdate:@"DELETE FROM queued_saved_hashes "
|
||
"WHERE story_hash = ? AND story_feed_id = ?",
|
||
storyHash, storyFeedId];
|
||
}
|
||
}];
|
||
|
||
return storyQueued;
|
||
}
|
||
|
||
- (void)flushQueuedSavedStories:(BOOL)forceCheck withCallback:(void(^)(void))callback {
|
||
if (self.feedsViewController.isOffline) {
|
||
if (callback) callback();
|
||
return;
|
||
}
|
||
|
||
if (self.hasQueuedSavedStories || forceCheck) {
|
||
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW,
|
||
(unsigned long)NULL), ^(void) {
|
||
[self.database inTransaction:^(FMDatabase *db, BOOL *rollback) {
|
||
FMResultSet *stories = [db executeQuery:@"SELECT * FROM queued_saved_hashes"];
|
||
__block NSMutableArray *requests = [NSMutableArray array];
|
||
|
||
while ([stories next]) {
|
||
NSString *storyFeedId = [NSString stringWithFormat:@"%@", [stories objectForColumnName:@"story_feed_id"]];
|
||
NSString *storyHash = [stories objectForColumnName:@"story_hash"];
|
||
BOOL saved = [stories boolForColumn:@"saved"];
|
||
NSDictionary *info = [NSJSONSerialization
|
||
JSONObjectWithData:[[stories stringForColumn:@"info_json"]
|
||
dataUsingEncoding:NSUTF8StringEncoding]
|
||
options:0 error:nil];
|
||
|
||
NSMutableDictionary *params = [NSMutableDictionary dictionary];
|
||
NSArray *userTags = info[@"user_tags"];
|
||
|
||
[params setObject:storyHash forKey:@"story_id"];
|
||
[params setObject:storyFeedId forKey:@"feed_id"];
|
||
|
||
if (saved) {
|
||
[params setObject:userTags forKey:@"user_tags"];
|
||
}
|
||
|
||
[requests addObject:params];
|
||
}
|
||
|
||
[stories close];
|
||
|
||
self.hasQueuedSavedStories = NO;
|
||
[self syncQueuedSavedStoriesRequests:requests withCallback:callback];
|
||
}];
|
||
});
|
||
} else {
|
||
if (callback) callback();
|
||
}
|
||
}
|
||
|
||
- (void)syncQueuedSavedStoriesRequests:(NSMutableArray *)requests withCallback:(void(^)(void))callback {
|
||
NSDictionary *params = requests.firstObject;
|
||
[requests removeObject:params];
|
||
|
||
if (!params) {
|
||
if (callback) callback();
|
||
return;
|
||
}
|
||
|
||
[self syncQueuedSavedStoryParams:params withCallback:^{
|
||
[self syncQueuedSavedStoriesRequests:requests withCallback:callback];
|
||
}];
|
||
}
|
||
|
||
- (void)syncQueuedSavedStoryParams:(NSDictionary *)params withCallback:(void(^)(void))callback {
|
||
BOOL saved = [params objectForKey:@"user_tags"] != nil;
|
||
NSString *endpoint = saved ? @"mark_story_as_starred" : @"mark_story_as_unstarred";
|
||
NSString *urlString = [NSString stringWithFormat:@"%@/reader/%@", self.url, endpoint];
|
||
|
||
[self POST:urlString parameters:params success:^(NSURLSessionDataTask * _Nonnull task, id _Nullable responseObject) {
|
||
NSString *storyHash = [params objectForKey:@"story_id"];
|
||
NSString *storyFeedId = [params objectForKey:@"feed_id"];
|
||
[self dequeueSavedStoryHash:storyHash inFeed:storyFeedId];
|
||
if (callback) callback();
|
||
} failure:^(NSURLSessionDataTask * _Nullable task, NSError * _Nonnull error) {
|
||
self.hasQueuedSavedStories = YES;
|
||
if (callback) callback();
|
||
}];
|
||
}
|
||
|
||
- (void)fetchTextForStory:(NSString *)storyHash inFeed:(NSString *)feedId checkCache:(BOOL)checkCache withCallback:(void(^)(NSString *))callback {
|
||
if (checkCache) {
|
||
[self privateGetCachedTextForStory:storyHash inFeed:feedId withCallback:^(NSString *text) {
|
||
if (text != nil) {
|
||
if (callback) {
|
||
callback(text);
|
||
}
|
||
} else {
|
||
[self privateFetchTextForStory:storyHash inFeed:feedId withCallback:callback];
|
||
}
|
||
}];
|
||
} else {
|
||
[self privateFetchTextForStory:storyHash inFeed:feedId withCallback:callback];
|
||
}
|
||
}
|
||
|
||
- (void)privateGetCachedTextForStory:(NSString *)storyHash inFeed:(NSString *)feedId withCallback:(void(^)(NSString *))callback {
|
||
[self.database inDatabase:^(FMDatabase *db) {
|
||
NSString *text = nil;
|
||
FMResultSet *cursor = [db executeQuery:@"SELECT * FROM cached_text "
|
||
"WHERE story_hash = ? AND story_feed_id = ? LIMIT 1",
|
||
storyHash, feedId];
|
||
while ([cursor next]) {
|
||
NSDictionary *textCache = [cursor resultDictionary];
|
||
NSString *json = [textCache objectForKey:@"text_json"];
|
||
|
||
if (json.length > 0) {
|
||
NSDictionary *results = [NSJSONSerialization
|
||
JSONObjectWithData:[json
|
||
dataUsingEncoding:NSUTF8StringEncoding]
|
||
options:0 error:nil];
|
||
text = results[@"text"];
|
||
|
||
if (text) {
|
||
NSLog(@"Found cached text: %@ bytes", @(text.length));
|
||
} else {
|
||
NSLog(@"Found cached failure");
|
||
}
|
||
}
|
||
}
|
||
[cursor close];
|
||
|
||
if (callback) {
|
||
callback(text);
|
||
}
|
||
}];
|
||
}
|
||
|
||
- (void)privateFetchTextForStory:(NSString *)storyHash inFeed:(NSString *)feedId withCallback:(void(^)(NSString *))callback {
|
||
NSString *urlString = [NSString stringWithFormat:@"%@/rss_feeds/original_text", self.url];
|
||
NSMutableDictionary *params = [NSMutableDictionary dictionary];
|
||
[params setObject:storyHash forKey:@"story_id"];
|
||
[params setObject:feedId forKey:@"feed_id"];
|
||
|
||
[self POST:urlString parameters:params success:^(NSURLSessionDataTask * _Nonnull task, id _Nullable responseObject) {
|
||
NSString *text = [responseObject objectForKey:@"original_text"];
|
||
|
||
if ([[responseObject objectForKey:@"failed"] boolValue]) {
|
||
text = nil;
|
||
}
|
||
|
||
if (callback) {
|
||
callback(text);
|
||
}
|
||
} failure:^(NSURLSessionDataTask * _Nullable task, NSError * _Nonnull error) {
|
||
if (callback) {
|
||
callback(nil);
|
||
}
|
||
}];
|
||
}
|
||
|
||
- (void)prepareActiveCachedImages:(FMDatabase *)db {
|
||
activeCachedImages = [NSMutableDictionary dictionary];
|
||
NSArray *feedIds;
|
||
int cached = 0;
|
||
|
||
if (storiesCollection.isRiverView) {
|
||
feedIds = storiesCollection.activeFolderFeeds;
|
||
} else if (storiesCollection.activeFeed) {
|
||
feedIds = @[[storiesCollection.activeFeed objectForKey:@"id"]];
|
||
}
|
||
NSString *sql = [NSString stringWithFormat:@"SELECT c.image_url, c.story_hash FROM cached_images c "
|
||
"WHERE c.image_cached = 1 AND c.failed is null AND c.story_feed_id in (\"%@\")",
|
||
[feedIds componentsJoinedByString:@"\",\""]];
|
||
FMResultSet *cursor = [db executeQuery:sql];
|
||
|
||
while ([cursor next]) {
|
||
NSString *storyHash = [cursor objectForColumnName:@"story_hash"];
|
||
NSMutableArray *imageUrls;
|
||
if (![activeCachedImages objectForKey:storyHash]) {
|
||
imageUrls = [NSMutableArray array];
|
||
[activeCachedImages setObject:imageUrls forKey:storyHash];
|
||
} else {
|
||
imageUrls = [activeCachedImages objectForKey:storyHash];
|
||
}
|
||
[imageUrls addObject:[cursor objectForColumnName:@"image_url"]];
|
||
[activeCachedImages setObject:imageUrls forKey:storyHash];
|
||
cached++;
|
||
}
|
||
|
||
// NSLog(@"Pre-cached %d images", cached);
|
||
}
|
||
|
||
- (void)cleanImageCache {
|
||
OfflineCleanImages *operationCleanImages = [[OfflineCleanImages alloc] init];
|
||
if (!offlineCleaningQueue) {
|
||
offlineCleaningQueue = [NSOperationQueue new];
|
||
}
|
||
[offlineCleaningQueue addOperation:operationCleanImages];
|
||
}
|
||
|
||
- (void)deleteAllCachedImages {
|
||
NSUInteger memorySize = 1024 * 1024 * 64;
|
||
NSURLCache *sharedCache = [[NSURLCache alloc] initWithMemoryCapacity:memorySize diskCapacity:memorySize diskPath:nil];
|
||
[NSURLCache setSharedURLCache:sharedCache];
|
||
NSLog(@"cap: %ld", (unsigned long)[[NSURLCache sharedURLCache] diskCapacity]);
|
||
|
||
NSInteger sizeInteger = [[NSURLCache sharedURLCache] currentDiskUsage];
|
||
float sizeInMB = sizeInteger / (1024.0f * 1024.0f);
|
||
NSLog(@"size: %ld, %f", (long)sizeInteger, sizeInMB);
|
||
|
||
[[NSURLCache sharedURLCache] removeAllCachedResponses];
|
||
|
||
sizeInteger = [[NSURLCache sharedURLCache] currentDiskUsage];
|
||
sizeInMB = sizeInteger / (1024.0f * 1024.0f);
|
||
NSLog(@"size: %ld, %f", (long)sizeInteger, sizeInMB);
|
||
|
||
[[NSURLCache sharedURLCache] removeAllCachedResponses];
|
||
|
||
sizeInteger = [[NSURLCache sharedURLCache] currentDiskUsage];
|
||
sizeInMB = sizeInteger / (1024.0f * 1024.0f);
|
||
NSLog(@"size: %ld, %f", (long)sizeInteger, sizeInMB);
|
||
|
||
[[NSURLCache sharedURLCache] removeAllCachedResponses];
|
||
|
||
[[PINCache sharedCache] removeAllObjects];
|
||
[self.cachedStoryImages removeAllObjects];
|
||
|
||
NSFileManager *fileManager = [[NSFileManager alloc] init];
|
||
NSError *error = nil;
|
||
NSArray *paths = NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES);
|
||
NSString *cacheDirectory = [[paths objectAtIndex:0] stringByAppendingPathComponent:@"story_images"];
|
||
NSArray *directoryContents = [fileManager contentsOfDirectoryAtPath:cacheDirectory error:&error];
|
||
int removed = 0;
|
||
|
||
if (error == nil) {
|
||
for (NSString *path in directoryContents) {
|
||
NSString *fullPath = [cacheDirectory stringByAppendingPathComponent:path];
|
||
BOOL removeSuccess = [fileManager removeItemAtPath:fullPath error:&error];
|
||
removed++;
|
||
if (!removeSuccess) {
|
||
continue;
|
||
}
|
||
}
|
||
}
|
||
|
||
NSLog(@"Deleted %d images.", removed);
|
||
|
||
|
||
}
|
||
@end
|
||
|
||
#pragma mark -
|
||
#pragma mark Unread Counts
|
||
|
||
|
||
@implementation UnreadCounts
|
||
|
||
@synthesize ps, nt, ng;
|
||
|
||
|
||
- (id)init {
|
||
if (self = [super init]) {
|
||
ps = 0;
|
||
nt = 0;
|
||
ng = 0;
|
||
}
|
||
return self;
|
||
}
|
||
|
||
- (void)addCounts:(UnreadCounts *)counts {
|
||
ps += counts.ps;
|
||
nt += counts.nt;
|
||
ng += counts.ng;
|
||
}
|
||
|
||
- (NSString *)description {
|
||
return [NSString stringWithFormat:@"PS: %d, NT: %d, NG: %d", ps, nt, ng];
|
||
}
|
||
|
||
@end
|